| f | module Cisco-IOS-XR-um-router-isis-cfg { | f | module Cisco-IOS-XR-um-router-isis-cfg { |
| namespace "http://cisco.com/ns/yang/Cisco-IOS-XR-um-router-isis-cfg"; | | namespace "http://cisco.com/ns/yang/Cisco-IOS-XR-um-router-isis-cfg"; |
| prefix um-router-isis-cfg; | | prefix um-router-isis-cfg; |
| | | |
| import Cisco-IOS-XR-types { | | import Cisco-IOS-XR-types { |
| prefix xr; | | prefix xr; |
| } | | } |
| import ietf-inet-types { | | import ietf-inet-types { |
| prefix inet; | | prefix inet; |
| } | | } |
| import Cisco-IOS-XR-um-snmp-server-cfg { | | import Cisco-IOS-XR-um-snmp-server-cfg { |
| prefix a1; | | prefix a1; |
| } | | } |
| import tailf-common { | | import tailf-common { |
| prefix tailf; | | prefix tailf; |
| } | | } |
| import cisco-semver { | | import cisco-semver { |
| prefix semver; | | prefix semver; |
| } | | } |
| | | |
| organization | | organization |
| "Cisco Systems, Inc."; | | "Cisco Systems, Inc."; |
| contact | | contact |
| "Cisco Systems, Inc. | | "Cisco Systems, Inc. |
| Customer Service | | Customer Service |
| | | |
| Postal: 170 West Tasman Drive | | Postal: 170 West Tasman Drive |
| San Jose, CA 95134 | | San Jose, CA 95134 |
| | | |
| Tel: +1 800 553-NETS | | Tel: +1 800 553-NETS |
| | | |
| E-mail: cs-yang@cisco.com"; | | E-mail: cs-yang@cisco.com"; |
| description | | description |
| "This module contains a collection of YANG definitions | | "This module contains a collection of YANG definitions |
| for Cisco IOS-XR router-isis package configuration. | | for Cisco IOS-XR router-isis package configuration. |
| | | |
| This YANG module augments the | | This YANG module augments the |
| modules with configuration data. | | modules with configuration data. |
| | | |
| n | Copyright (c) 2019-2024 by Cisco Systems, Inc. | n | Copyright (c) 2019-2022 by Cisco Systems, Inc. |
| All rights reserved."; | | All rights reserved."; |
| | | |
| n | revision 2024-02-05 { | n | |
| description | | |
| "Correct container distribute-list metadata | | |
| 2024-02-01 | | |
| Add ip-only support | | |
| 2024-01-05 | | |
| Add Log Size | | |
| 2023-11-21 | | |
| Add Generic-metric | | |
| 2023-11-09 | | |
| Add lsp-fast-flooding submode, psnp-interval and if remote-psnp-delay | | |
| 2023-11-09 | | |
| Add oor-set-overload-bit | | |
| 2023-08-22 | | |
| Add nsr-restart-time | | |
| 2023-07-12 | | |
| Add flex-algo UCMP | | |
| 2023-06-28 | | |
| Change the must clause from ../../srv6-locator-xxx to srv6-locator-xxx | | |
| 2023-04-09 | | |
| Add maximum paths per route-policy for standard and flex algo | | |
| 2023-04-03 | | |
| Add flex-algo MinimumBandwidth and MaximumDelay constraints | | |
| 2023-03-13 | | |
| Add Uloop filtering suport | | |
| 2023-02-10 | | |
| Modify must statement for SPF interval per-level | | |
| 2022-11-18 | | |
| Add distribute link-state prefix filtering | | |
| 2022-10-14 | | |
| Added new nodes for partition-detect | | |
| 2022-10-04 | | |
| Added support for ISIS Prefix-SID UHP | | |
| 2022-10-02 | | |
| Added hello-padding under router-isis | | |
| 2022-10-01 | | |
| Add support for flex-algo reverse link affinities. | | |
| 2022-07-25 | | |
| Added new node anycast-prefer-igp-cost to traffic-eng tunnel | | |
| 2022-07-18 | | |
| Added new node php-disable to the existing connected-prefix-sid-map, strict-spf and flex-algo. | | |
| 2022-07-11 | | |
| Added missing description statement to nodes | | |
| 2022-05-12 | | |
| Added new node adv-unreachable with sub-node unreachable-component-tag and tag value to an existing ISIS address-family sub-mode summary-prefix command.Added new node prefix-unreachable under ISIS address-family sub-mode. | | |
| 2022-05-05 | | |
| Added new node anomaly to the existing ISIS affinity flex-algo | | |
| 2022-04-22 | | |
| Added support for maximum-paths under flex-algo, | | |
| Added container algorithm | | |
| 2022-04-05 | | |
| Added support for te and delay | | |
| 2022-03-03 | | |
| Added container metric & tag under segment-routing/srv6/locators, | | |
| Added container format, | | |
| Added container lsp-fast-flood | | |
| 2022-01-19 | | |
| Added ietf support for spf-interval | | |
| 2022-01-04 | | |
| Added support for unhidden CLI commands | | |
| 2021-12-14 | | |
| Added authentication-check feature"; | | |
| semver:module-version "5.0.0"; | | |
| } | | |
| revision 2021-09-23 { | | revision 2021-09-23 { |
| description | | description |
| "Merged container levels under disable|interval/periodic/address-family-topology, | | "Merged container levels under disable|interval/periodic/address-family-topology, |
| n | Merged container levels under disable|interval/periodic/address-family, | n | Merged container levels under disable|interval/periodic/address-family, |
| Merged disable & interval-time into one leaf interval | | Merged disable & interval-time into one leaf interval |
| 2021-07-27 | | 2021-07-27 |
| n | Re-ordered maximum-wait, initial-wait and secondary-wait nodes under | n | Re-ordered maximum-wait, initial-wait and secondary-wait nodes under |
| level container/spf-interval | | level container/spf-interval |
| 2021-06-15 | | 2021-06-15 |
| n | Added when statement to container prefix-attributes"; | n | Added when statement to container prefix-attributes"; |
| semver:module-version "4.0.0"; | | semver:module-version "4.0.0"; |
| } | | } |
| revision 2021-05-18 { | | revision 2021-05-18 { |
| description | | description |
| "Added features, 1. flex-algo srlg exclude | | "Added features, 1. flex-algo srlg exclude |
| 2. advertise application flex-algo link-attributes srlg | | 2. advertise application flex-algo link-attributes srlg |
| 2021-04-22 | | 2021-04-22 |
| n | Added te-metric flex-algo feature | n | Added te-metric flex-algo feature |
| 2021-03-02 | | 2021-03-02 |
| n | Re-ordered maximum-wait, initial-wait and secondary-wait nodes under | n | Re-ordered maximum-wait, initial-wait and secondary-wait nodes under |
| level container | | level container |
| 2021-02-11 | | 2021-02-11 |
| n | Re-ordered per-link, per-prefix nodes under interface fast-reroute container | n | Re-ordered per-link, per-prefix nodes under interface fast-reroute container |
| 2021-01-28 | | 2021-01-28 |
| n | Added cisco-support task yang nodes | n | Added cisco-support task yang nodes |
| 2021-01-27 | | 2021-01-27 |
| n | Re-ordered nodes under lsp-gen-interval, min-lsp-arrivaltime container | n | Re-ordered nodes under lsp-gen-interval, min-lsp-arrivaltime container |
| 2021-01-20 | | 2021-01-20 |
| n | Moved presence containers as leafs under snmp-server traps | n | Moved presence containers as leafs under snmp-server traps |
| 2021-01-18 | | 2021-01-18 |
| n | Added presence statement and re-ordered few nodes under container max-metric | n | Added presence statement and re-ordered few nodes under container max-metric |
| 2021-01-11 | | 2021-01-11 |
| n | Add support to metric and preferred container under tunnel | n | Add support to metric and preferred container under tunnel |
| 2021-01-07 | | 2021-01-07 |
| n | Updated range value in leaf multiplier under fallback container | n | Updated range value in leaf multiplier under fallback container |
| 2021-01-06 | | 2021-01-06 |
| n | Added presence statement under link-state container | n | Added presence statement under link-state container |
| 2020-12-09 | | 2020-12-09 |
| n | Removed cisco-support yang nodes | n | Removed cisco-support yang nodes |
| 2020-12-01 | | 2020-12-01 |
| n | Added container anomaly under metric/fallback | n | Added container anomaly under metric/fallback |
| 2020-11-20 | | 2020-11-20 |
| n | Added metric type te | n | Added metric type te |
| 2020-11-19 | | 2020-11-19 |
| n | Fixed a must statement under absolute, added presence statement to text | n | Fixed a must statement under absolute, added presence statement to text |
| 2020-11-13 | | 2020-11-13 |
| n | Added container receive and attestation under list process. | n | Added container receive and attestation under list process. |
| 2020-11-02 | | 2020-11-02 |
| n | Moved levels container under lsp-password out of it and renamed as | n | Moved levels container under lsp-password out of it and renamed as |
| lsp-password-levels. | | lsp-password-levels. |
| 2020-08-20 | | 2020-08-20 |
| n | Added level option under srv6/locator | n | Added level option under srv6/locator |
| 2020-08-13 | | 2020-08-13 |
| n | Remove presence container and constraints on the match container | n | Remove presence container and constraints on the match container |
| 2020-08-10 | | 2020-08-10 |
| n | Updated the fallback topology | n | Updated the fallback topology |
| 2020-07-21 | | 2020-07-21 |
| n | Slight changes to prefix-priority nodes | n | Slight changes to prefix-priority nodes |
| 2020-07-17 | | 2020-07-17 |
| n | Added must statements and moved rib-update-delay up one node | n | Added must statements and moved rib-update-delay up one node |
| 2020-07-15 | | 2020-07-15 |
| n | Added down-flag-clear node under redistribute isis | n | Added down-flag-clear node under redistribute isis |
| 2020-07-14 | | 2020-07-14 |
| n | Added mandatory node to bit-position under affinity-map"; | n | Added mandatory node to bit-position under affinity-map"; |
| semver:module-version "3.0.0"; | | semver:module-version "3.0.0"; |
| } | | } |
| revision 2020-05-19 { | | revision 2020-05-19 { |
| description | | description |
| "Added nodes for new ISIS features | | "Added nodes for new ISIS features |
| 2020-05-07 | | 2020-05-07 |
| n | Added a container anycast and its child nodes | n | Added a container anycast and its child nodes |
| 2020-04-14 | | 2020-04-14 |
| n | Updated the constraints in the nodes under stagger to be less strict | n | Updated the constraints in the nodes under stagger to be less strict |
| 2020-03-09 | | 2020-03-09 |
| n | Updated lsp-password and summary-prefix trees with proper constaraint | n | Updated lsp-password and summary-prefix trees with proper constaraint |
| statements"; | | statements"; |
| semver:module-version "2.0.0"; | | semver:module-version "2.0.0"; |
| } | | } |
| revision 2019-06-10 { | | revision 2019-06-10 { |
| description | | description |
| "Establish semantic version baseline."; | | "Establish semantic version baseline."; |
| semver:module-version "1.0.0"; | | semver:module-version "1.0.0"; |
| } | | } |
| revision 2019-03-30 { | | revision 2019-03-30 { |
| description | | description |
| "Initial draft"; | | "Initial draft"; |
| } | | } |
| | | |
| typedef Isis-af-name { | | typedef Isis-af-name { |
| type enumeration { | | type enumeration { |
| enum "ipv4" { | | enum "ipv4" { |
| value 0; | | value 0; |
| description | | description |
| "IPv4"; | | "IPv4"; |
| } | | } |
| enum "ipv6" { | | enum "ipv6" { |
| value 1; | | value 1; |
| description | | description |
| "IPv6"; | | "IPv6"; |
| } | | } |
| } | | } |
| description | | description |
| "Address-family names"; | | "Address-family names"; |
| } | | } |
| | | |
| typedef Isis-saf-name { | | typedef Isis-saf-name { |
| type enumeration { | | type enumeration { |
| enum "unicast" { | | enum "unicast" { |
| value 0; | | value 0; |
| description | | description |
| "unicast"; | | "unicast"; |
| } | | } |
| enum "multicast" { | | enum "multicast" { |
| value 1; | | value 1; |
| description | | description |
| "multicast"; | | "multicast"; |
| } | | } |
| } | | } |
| description | | description |
| "Sub address-family names"; | | "Sub address-family names"; |
| } | | } |
| | | |
| typedef Isis-saf-multicast { | | typedef Isis-saf-multicast { |
| type enumeration { | | type enumeration { |
| enum "multicast" { | | enum "multicast" { |
| value 1; | | value 1; |
| description | | description |
| "multicast"; | | "multicast"; |
| } | | } |
| } | | } |
| description | | description |
| "Sub address-family names (only multicast)"; | | "Sub address-family names (only multicast)"; |
| } | | } |
| | | |
| augment "/a1:snmp-server/a1:traps" { | | augment "/a1:snmp-server/a1:traps" { |
| n | description | n | |
| "This augment extends snmp-server traps nodes | | |
| configuration"; | | |
| container isis { | | container isis { |
| must | | must |
| "not(all = 'enable' and | | "not(all = 'enable' and |
| (database-overload = 'enable' or | | (database-overload = 'enable' or |
| manual-address-drops = 'enable' or | | manual-address-drops = 'enable' or |
| corrupted-lsp-detected = 'enable' or | | corrupted-lsp-detected = 'enable' or |
| attempt-to-exceed-max-sequence = 'enable' or | | attempt-to-exceed-max-sequence = 'enable' or |
| id-len-mismatch = 'enable' or | | id-len-mismatch = 'enable' or |
| max-area-addresses-mismatch = 'enable' or | | max-area-addresses-mismatch = 'enable' or |
| own-lsp-purge = 'enable' or | | own-lsp-purge = 'enable' or |
| sequence-number-skip = 'enable' or | | sequence-number-skip = 'enable' or |
| authentication-type-failure = 'enable' or | | authentication-type-failure = 'enable' or |
| authentication-failure = 'enable' or | | authentication-failure = 'enable' or |
| version-skew = 'enable' or | | version-skew = 'enable' or |
| area-mismatch = 'enable' or | | area-mismatch = 'enable' or |
| rejected-adjacency = 'enable' or | | rejected-adjacency = 'enable' or |
| lsp-too-large-to-propagate = 'enable' or | | lsp-too-large-to-propagate = 'enable' or |
| orig-lsp-buff-size-mismatch = 'enable' or | | orig-lsp-buff-size-mismatch = 'enable' or |
| protocols-supported-mismatch = 'enable' or | | protocols-supported-mismatch = 'enable' or |
| adjacency-change = 'enable' or | | adjacency-change = 'enable' or |
| lsp-error-detected = 'enable'))"; | | lsp-error-detected = 'enable'))"; |
| presence "Indicates a isis node is configured."; | | presence "Indicates a isis node is configured."; |
| description | | description |
| "Enable IS-IS traps"; | | "Enable IS-IS traps"; |
| leaf all { | | leaf all { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 19; | | value 19; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Enable all IS-IS traps"; | | "Enable all IS-IS traps"; |
| } | | } |
| leaf database-overload { | | leaf database-overload { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 1; | | value 1; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisDatabaseOverload"; | | "isisDatabaseOverload"; |
| } | | } |
| leaf manual-address-drops { | | leaf manual-address-drops { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 2; | | value 2; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisManualAddressDrops"; | | "isisManualAddressDrops"; |
| } | | } |
| leaf corrupted-lsp-detected { | | leaf corrupted-lsp-detected { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 3; | | value 3; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisCorruptedLSPDetected"; | | "isisCorruptedLSPDetected"; |
| } | | } |
| leaf attempt-to-exceed-max-sequence { | | leaf attempt-to-exceed-max-sequence { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 4; | | value 4; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisAttemptToExceedMaxSequence"; | | "isisAttemptToExceedMaxSequence"; |
| } | | } |
| leaf id-len-mismatch { | | leaf id-len-mismatch { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 5; | | value 5; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisIDLenMismatch"; | | "isisIDLenMismatch"; |
| } | | } |
| leaf max-area-addresses-mismatch { | | leaf max-area-addresses-mismatch { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 6; | | value 6; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisMaxAreaAddressesMismatch"; | | "isisMaxAreaAddressesMismatch"; |
| } | | } |
| leaf own-lsp-purge { | | leaf own-lsp-purge { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 7; | | value 7; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisOwnLSPPurge"; | | "isisOwnLSPPurge"; |
| } | | } |
| leaf sequence-number-skip { | | leaf sequence-number-skip { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 8; | | value 8; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisSequenceNumberSkip"; | | "isisSequenceNumberSkip"; |
| } | | } |
| leaf authentication-type-failure { | | leaf authentication-type-failure { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 9; | | value 9; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisAuthenticationTypeFailure"; | | "isisAuthenticationTypeFailure"; |
| } | | } |
| leaf authentication-failure { | | leaf authentication-failure { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 10; | | value 10; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisAuthenticationFailure"; | | "isisAuthenticationFailure"; |
| } | | } |
| leaf version-skew { | | leaf version-skew { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 11; | | value 11; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisVersionSkew"; | | "isisVersionSkew"; |
| } | | } |
| leaf area-mismatch { | | leaf area-mismatch { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 12; | | value 12; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisAreaMismatch"; | | "isisAreaMismatch"; |
| } | | } |
| leaf rejected-adjacency { | | leaf rejected-adjacency { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 13; | | value 13; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisRejectedAdjacency"; | | "isisRejectedAdjacency"; |
| } | | } |
| leaf lsp-too-large-to-propagate { | | leaf lsp-too-large-to-propagate { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 14; | | value 14; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisLSPTooLargeToPropagate"; | | "isisLSPTooLargeToPropagate"; |
| } | | } |
| leaf orig-lsp-buff-size-mismatch { | | leaf orig-lsp-buff-size-mismatch { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 15; | | value 15; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisOrigLSPBuffSizeMismatch"; | | "isisOrigLSPBuffSizeMismatch"; |
| } | | } |
| leaf protocols-supported-mismatch { | | leaf protocols-supported-mismatch { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 16; | | value 16; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisProtocolsSupportedMismatch"; | | "isisProtocolsSupportedMismatch"; |
| } | | } |
| leaf adjacency-change { | | leaf adjacency-change { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 17; | | value 17; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisAdjacencyChange"; | | "isisAdjacencyChange"; |
| } | | } |
| leaf lsp-error-detected { | | leaf lsp-error-detected { |
| type enumeration { | | type enumeration { |
| enum "enable" { | | enum "enable" { |
| value 18; | | value 18; |
| description | | description |
| "Enable the trap"; | | "Enable the trap"; |
| } | | } |
| enum "disable" { | | enum "disable" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the trap"; | | "Disable the trap"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "isisLSPErrorDetected"; | | "isisLSPErrorDetected"; |
| } | | } |
| } | | } |
| } | | } |
| container router { | | container router { |
| description | | description |
| "Enable a routing process"; | | "Enable a routing process"; |
| container isis { | | container isis { |
| description | | description |
| "ISO IS-IS"; | | "ISO IS-IS"; |
| container processes { | | container processes { |
| description | | description |
| "Process ID"; | | "Process ID"; |
| list process { | | list process { |
| key "process-id"; | | key "process-id"; |
| description | | description |
| "Process ID"; | | "Process ID"; |
| leaf process-id { | | leaf process-id { |
| type string { | | type string { |
| length "1..36" { | | length "1..36" { |
| description | | description |
| "Process ID"; | | "Process ID"; |
| } | | } |
| } | | } |
| description | | description |
| "Process ID"; | | "Process ID"; |
| } | | } |
| container nsr { | | container nsr { |
| presence "Indicates a nsr node is configured."; | | presence "Indicates a nsr node is configured."; |
| description | | description |
| "Enable NSR"; | | "Enable NSR"; |
| } | | } |
| n | leaf nsr-restart-time { | n | |
| type uint32 { | | |
| range "60..300" { | | |
| description | | |
| "Maximum time allowed to resync following NSR, default is 60"; | | |
| } | | |
| } | | |
| description | | |
| "Maximum time allowed to resync following NSR"; | | |
| } | | |
| container ignore-lsp-errors { | | container ignore-lsp-errors { |
| description | | description |
| "Ignore LSPs with bad checksums instead of purging the LSP"; | | "Ignore LSPs with bad checksums instead of purging the LSP"; |
| container disable { | | container disable { |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Purge LSPs with failed checksums"; | | "Purge LSPs with failed checksums"; |
| } | | } |
| } | | } |
| leaf instance-id { | | leaf instance-id { |
| type uint32 { | | type uint32 { |
| range "1..65535" { | | range "1..65535" { |
| description | | description |
| "Instance id"; | | "Instance id"; |
| } | | } |
| } | | } |
| description | | description |
| "ISIS-MI instance id"; | | "ISIS-MI instance id"; |
| } | | } |
| leaf is-type { | | leaf is-type { |
| type enumeration { | | type enumeration { |
| enum "level-1" { | | enum "level-1" { |
| value 1; | | value 1; |
| description | | description |
| "Act as a station router only"; | | "Act as a station router only"; |
| } | | } |
| enum "level-2-only" { | | enum "level-2-only" { |
| value 2; | | value 2; |
| description | | description |
| "Act as an area router only"; | | "Act as an area router only"; |
| } | | } |
| enum "level-1-2" { | | enum "level-1-2" { |
| value 3; | | value 3; |
| description | | description |
| "Act as both a station router and an area router"; | | "Act as both a station router and an area router"; |
| } | | } |
| } | | } |
| description | | description |
| "Area type (level)"; | | "Area type (level)"; |
| } | | } |
| container log { | | container log { |
| description | | description |
| "Enable logging"; | | "Enable logging"; |
| container adjacency { | | container adjacency { |
| description | | description |
| "Enable logging of adjacency state"; | | "Enable logging of adjacency state"; |
| container changes { | | container changes { |
| presence "Indicates a changes node is configured."; | | presence "Indicates a changes node is configured."; |
| description | | description |
| "Enable logging adjacency state changes"; | | "Enable logging adjacency state changes"; |
| } | | } |
| } | | } |
| container pdu { | | container pdu { |
| description | | description |
| "Enable PDU logging"; | | "Enable PDU logging"; |
| container drops { | | container drops { |
| presence "Indicates a drops node is configured."; | | presence "Indicates a drops node is configured."; |
| description | | description |
| "Enable logging PDU drops"; | | "Enable logging PDU drops"; |
| n | } | n | |
| } | | |
| container format { | | |
| description | | |
| "Select log message format"; | | |
| container brief { | | |
| presence "Indicates a brief node is configured."; | | |
| description | | |
| "Don't add additional information to ISIS log messages"; | | |
| } | | |
| } | | |
| container size { | | |
| description | | |
| "Configure Log Size"; | | |
| container adjacency { | | |
| description | | |
| "Adjacency Log Size"; | | |
| leaf size { | | |
| type uint32 { | | |
| range "20..50000" { | | |
| description | | |
| "Size"; | | |
| } | | |
| } | | |
| description | | |
| "Size of the Adjacency Log"; | | |
| } | | |
| } | | |
| container database { | | |
| description | | |
| "Database Log Size"; | | |
| leaf size { | | |
| type uint32 { | | |
| range "20..50000" { | | |
| description | | |
| "Size"; | | |
| } | | |
| } | | |
| description | | |
| "Size of the Database Log"; | | |
| } | | |
| } | | |
| container error { | | |
| description | | |
| "Error Log Size"; | | |
| leaf size { | | |
| type uint32 { | | |
| range "20..50000" { | | |
| description | | |
| "Size"; | | |
| } | | |
| } | | |
| description | | |
| "Size of the Error Log"; | | |
| } | | |
| } | | |
| container lsp { | | |
| description | | |
| "LSP Log Size"; | | |
| leaf size { | | |
| type uint32 { | | |
| range "20..50000" { | | |
| description | | |
| "Size"; | | |
| } | | |
| } | | |
| description | | |
| "Size of the LSP Log"; | | |
| } | | |
| } | | |
| container microloop-avoidance { | | |
| description | | |
| "Microloop Avoidance Log Size"; | | |
| leaf size { | | |
| type uint32 { | | |
| range "20..50000" { | | |
| description | | |
| "Size"; | | |
| } | | |
| } | | |
| description | | |
| "Size of the Microloop Avoidance Log"; | | |
| } | | |
| } | | |
| container route { | | |
| description | | |
| "Route Log Size"; | | |
| leaf size { | | |
| type uint32 { | | |
| range "20..50000" { | | |
| description | | |
| "Size"; | | |
| } | | |
| } | | |
| description | | |
| "Size of the Route Log"; | | |
| } | | |
| } | | |
| container spf { | | |
| description | | |
| "SPF Log Size"; | | |
| leaf size { | | |
| type uint32 { | | |
| range "20..50000" { | | |
| description | | |
| "Size"; | | |
| } | | |
| } | | |
| description | | |
| "Size of the SPF Log"; | | |
| } | | |
| } | | } |
| } | | } |
| } | | } |
| container lsp-password { | | container lsp-password { |
| must "text or hmac-md5 or keychain"; | | must "text or hmac-md5 or keychain"; |
| presence "Indicates a lsp-password node is configured."; | | presence "Indicates a lsp-password node is configured."; |
| description | | description |
| "Configure the area password"; | | "Configure the area password"; |
| container text { | | container text { |
| must "not(../hmac-md5 or ../keychain)"; | | must "not(../hmac-md5 or ../keychain)"; |
| presence "Indicates a text node is configured."; | | presence "Indicates a text node is configured."; |
| description | | description |
| "Use cleartext password authentication"; | | "Use cleartext password authentication"; |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| mandatory true; | | mandatory true; |
| description | | description |
| "The encrypted LSP/SNP password"; | | "The encrypted LSP/SNP password"; |
| } | | } |
| } | | } |
| container hmac-md5 { | | container hmac-md5 { |
| must "not(../text or ../keychain)"; | | must "not(../text or ../keychain)"; |
| presence "Indicates a hmac-md5 node is configured."; | | presence "Indicates a hmac-md5 node is configured."; |
| description | | description |
| "Use HMAC-MD5 authentication"; | | "Use HMAC-MD5 authentication"; |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| mandatory true; | | mandatory true; |
| description | | description |
| "The encrypted LSP/SNP password"; | | "The encrypted LSP/SNP password"; |
| } | | } |
| } | | } |
| container keychain { | | container keychain { |
| must "not(../hmac-md5 or ../text)"; | | must "not(../hmac-md5 or ../text)"; |
| presence "Indicates a keychain node is configured."; | | presence "Indicates a keychain node is configured."; |
| description | | description |
| "Specifies a Key Chain name will follow"; | | "Specifies a Key Chain name will follow"; |
| leaf keychain-name { | | leaf keychain-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "The Key Chain name"; | | "The Key Chain name"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specifies a Key Chain name will follow"; | | "Specifies a Key Chain name will follow"; |
| } | | } |
| } | | } |
| container send-only { | | container send-only { |
| must "../text or ../hmac-md5 or ../keychain"; | | must "../text or ../hmac-md5 or ../keychain"; |
| presence "Indicates a send-only node is configured."; | | presence "Indicates a send-only node is configured."; |
| description | | description |
| "Authenticate outgoing LSPs/SNPs only"; | | "Authenticate outgoing LSPs/SNPs only"; |
| } | | } |
| container snp { | | container snp { |
| description | | description |
| "Specify SNP packets authentication mode"; | | "Specify SNP packets authentication mode"; |
| container send-only { | | container send-only { |
| must "../../text"; | | must "../../text"; |
| presence "Indicates a send-only node is configured."; | | presence "Indicates a send-only node is configured."; |
| description | | description |
| "Authenticate outgoing SNPs, no check on incoming SNPs"; | | "Authenticate outgoing SNPs, no check on incoming SNPs"; |
| } | | } |
| } | | } |
| container enable-poi { | | container enable-poi { |
| must "../hmac-md5 or ../keychain"; | | must "../hmac-md5 or ../keychain"; |
| presence "Indicates a enable-poi node is configured."; | | presence "Indicates a enable-poi node is configured."; |
| description | | description |
| "Enable purge originator identification"; | | "Enable purge originator identification"; |
| } | | } |
| } | | } |
| container lsp-password-levels { | | container lsp-password-levels { |
| description | | description |
| "Set lsp-password for one level only"; | | "Set lsp-password for one level only"; |
| list level { | | list level { |
| must "text or hmac-md5 or keychain"; | | must "text or hmac-md5 or keychain"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set lsp-password for one level only"; | | "Set lsp-password for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set lsp-password for LSPs/SNPs at this level only"; | | "Set lsp-password for LSPs/SNPs at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set lsp-password for one level only"; | | "Set lsp-password for one level only"; |
| } | | } |
| container text { | | container text { |
| must "not(../hmac-md5 or ../keychain)"; | | must "not(../hmac-md5 or ../keychain)"; |
| presence "Indicates a hmac-md5 node is configured."; | | presence "Indicates a hmac-md5 node is configured."; |
| description | | description |
| "Use cleartext password authentication"; | | "Use cleartext password authentication"; |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| mandatory true; | | mandatory true; |
| description | | description |
| "The encrypted LSP/SNP password"; | | "The encrypted LSP/SNP password"; |
| } | | } |
| } | | } |
| container hmac-md5 { | | container hmac-md5 { |
| must "not(../text or ../keychain)"; | | must "not(../text or ../keychain)"; |
| presence "Indicates a hmac-md5 node is configured."; | | presence "Indicates a hmac-md5 node is configured."; |
| description | | description |
| "Use HMAC-MD5 authentication"; | | "Use HMAC-MD5 authentication"; |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| mandatory true; | | mandatory true; |
| description | | description |
| "The encrypted LSP/SNP password"; | | "The encrypted LSP/SNP password"; |
| } | | } |
| } | | } |
| container keychain { | | container keychain { |
| must "not(../text or ../hmac-md5)"; | | must "not(../text or ../hmac-md5)"; |
| presence "Indicates a keychain node is configured."; | | presence "Indicates a keychain node is configured."; |
| description | | description |
| "Specifies a Key Chain name will follow"; | | "Specifies a Key Chain name will follow"; |
| leaf keychain-name { | | leaf keychain-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "The Key Chain name"; | | "The Key Chain name"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specifies a Key Chain name will follow"; | | "Specifies a Key Chain name will follow"; |
| } | | } |
| } | | } |
| container send-only { | | container send-only { |
| must "../text or ../hmac-md5 or ../keychain"; | | must "../text or ../hmac-md5 or ../keychain"; |
| presence "Indicates a send-only node is configured."; | | presence "Indicates a send-only node is configured."; |
| description | | description |
| "Authenticate outgoing LSPs/SNPs only"; | | "Authenticate outgoing LSPs/SNPs only"; |
| } | | } |
| container snp { | | container snp { |
| description | | description |
| "Specify SNP packets authentication mode"; | | "Specify SNP packets authentication mode"; |
| container send-only { | | container send-only { |
| must "../../text"; | | must "../../text"; |
| presence "Indicates a send-only node is configured."; | | presence "Indicates a send-only node is configured."; |
| description | | description |
| "Authenticate outgoing SNPs, no check on incoming SNPs"; | | "Authenticate outgoing SNPs, no check on incoming SNPs"; |
| } | | } |
| } | | } |
| container enable-poi { | | container enable-poi { |
| must "../hmac-md5 or ../keychain"; | | must "../hmac-md5 or ../keychain"; |
| presence "Indicates a enable-poi node is configured."; | | presence "Indicates a enable-poi node is configured."; |
| description | | description |
| "Enable purge originator identification"; | | "Enable purge originator identification"; |
| } | | } |
| } | | } |
| container accept { | | container accept { |
| description | | description |
| "Use password for incoming authentication only"; | | "Use password for incoming authentication only"; |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| description | | description |
| "The encrypted LSP/SNP password"; | | "The encrypted LSP/SNP password"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set lsp-password for one level only"; | | "Set lsp-password for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set lsp-password for one level only"; | | "Set lsp-password for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set lsp-password for LSPs/SNPs at this level only"; | | "Set lsp-password for LSPs/SNPs at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set lsp-password for one level only"; | | "Set lsp-password for one level only"; |
| } | | } |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| mandatory true; | | mandatory true; |
| description | | description |
| "The encrypted LSP/SNP password"; | | "The encrypted LSP/SNP password"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| n | container authentication-check { | n | |
| description | | |
| "Check authentication type and key of isis PDUs"; | | |
| container disable { | | |
| presence "Indicates a disable node is configured."; | | |
| description | | |
| "Disable authentication check"; | | |
| } | | |
| } | | |
| leaf vrf-context { | | leaf vrf-context { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "VRF name (must not be 'default')"; | | "VRF name (must not be 'default')"; |
| } | | } |
| } | | } |
| description | | description |
| "VRF context for this ISIS process"; | | "VRF context for this ISIS process"; |
| } | | } |
| container hostname { | | container hostname { |
| description | | description |
| "Dynamic hostname resolution for show/debug output"; | | "Dynamic hostname resolution for show/debug output"; |
| container dynamic { | | container dynamic { |
| description | | description |
| "Dynamic hostname resolution"; | | "Dynamic hostname resolution"; |
| container disable { | | container disable { |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable dynamic hostname resolution"; | | "Disable dynamic hostname resolution"; |
| } | | } |
| } | | } |
| n | } | n | |
| container lsp-fast-flooding { | | |
| presence "Indicates a lsp-fast-flooding node is configured."; | | |
| description | | |
| "Enable and enter LSP fast flooding submode"; | | |
| leaf max-lsp-tx { | | |
| type uint32 { | | |
| range "33..5000" { | | |
| description | | |
| "Maximum LSP transmit rate (LSP per second), default is 1000"; | | |
| } | | |
| } | | |
| description | | |
| "Set maximum LSP transmit rate"; | | |
| } | | |
| leaf remote-psnp-delay { | | |
| type uint32 { | | |
| range "1..10000" { | | |
| description | | |
| "remote PSNP delay (milliseconds), default is 500"; | | |
| } | | |
| } | | |
| description | | |
| "Set remote PSNP delay"; | | |
| } | | |
| } | | |
| leaf psnp-interval { | | |
| type uint32 { | | |
| range "1..5000" { | | |
| description | | |
| "Longest wait to send PSNP, default is 50"; | | |
| } | | |
| } | | |
| description | | |
| "Longest wait to send PSNP"; | | |
| } | | } |
| container lsp-check-interval { | | container lsp-check-interval { |
| description | | description |
| "Set LSP checksum check interval"; | | "Set LSP checksum check interval"; |
| leaf lsp-check-interval-time { | | leaf lsp-check-interval-time { |
| type uint32 { | | type uint32 { |
| range "10..65535" { | | range "10..65535" { |
| description | | description |
| "LSP checksum check interval time in seconds"; | | "LSP checksum check interval time in seconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Set LSP checksum check interval"; | | "Set LSP checksum check interval"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set LSP check interval for one level only"; | | "Set LSP check interval for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set LSP check interval for one level only"; | | "Set LSP check interval for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set LSP check interval for one level only"; | | "Set LSP check interval for one level only"; |
| } | | } |
| leaf lsp-check-interval-time { | | leaf lsp-check-interval-time { |
| type uint32 { | | type uint32 { |
| range "10..65535" { | | range "10..65535" { |
| description | | description |
| "LSP checksum check interval time in seconds"; | | "LSP checksum check interval time in seconds"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set LSP checksum check interval"; | | "Set LSP checksum check interval"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container lsp-gen-interval { | | container lsp-gen-interval { |
| must "maximum-wait or initial-wait or secondary-wait"; | | must "maximum-wait or initial-wait or secondary-wait"; |
| presence "Indicates a lsp-gen-interval node is configured."; | | presence "Indicates a lsp-gen-interval node is configured."; |
| description | | description |
| "System and Pseudonode LSP generation scheduling parameters"; | | "System and Pseudonode LSP generation scheduling parameters"; |
| leaf maximum-wait { | | leaf maximum-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum delay before generating an LSP"; | | "Maximum delay before generating an LSP"; |
| } | | } |
| leaf initial-wait { | | leaf initial-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Initial delay before generating an LSP"; | | "Initial delay before generating an LSP"; |
| } | | } |
| leaf secondary-wait { | | leaf secondary-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Secondary delay before generating an LSP"; | | "Secondary delay before generating an LSP"; |
| } | | } |
| } | | } |
| container lsp-gen-interval-levels { | | container lsp-gen-interval-levels { |
| description | | description |
| "Set LSP generation interval for one level only"; | | "Set LSP generation interval for one level only"; |
| list level { | | list level { |
| must "maximum-wait or initial-wait or secondary-wait"; | | must "maximum-wait or initial-wait or secondary-wait"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set LSP generation interval for one level only"; | | "Set LSP generation interval for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set LSP generation interval for one level only"; | | "Set LSP generation interval for one level only"; |
| } | | } |
| leaf maximum-wait { | | leaf maximum-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum delay before generating an LSP"; | | "Maximum delay before generating an LSP"; |
| } | | } |
| leaf initial-wait { | | leaf initial-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Initial delay before generating an LSP"; | | "Initial delay before generating an LSP"; |
| } | | } |
| leaf secondary-wait { | | leaf secondary-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Secondary delay before generating an LSP"; | | "Secondary delay before generating an LSP"; |
| } | | } |
| } | | } |
| } | | } |
| container max-lsp-lifetime { | | container max-lsp-lifetime { |
| description | | description |
| "Set maximum LSP lifetime"; | | "Set maximum LSP lifetime"; |
| leaf max-lsp-lifetime { | | leaf max-lsp-lifetime { |
| type uint32 { | | type uint32 { |
| range "1..65535" { | | range "1..65535" { |
| description | | description |
| "Maximum LSP lifetime in seconds"; | | "Maximum LSP lifetime in seconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Set maximum LSP lifetime"; | | "Set maximum LSP lifetime"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set LSP regeneration interval for one level only"; | | "Set LSP regeneration interval for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set LSP regeneration interval for one level only"; | | "Set LSP regeneration interval for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set LSP regeneration interval for one level only"; | | "Set LSP regeneration interval for one level only"; |
| } | | } |
| leaf max-lsp-lifetime { | | leaf max-lsp-lifetime { |
| type uint32 { | | type uint32 { |
| range "1..65535" { | | range "1..65535" { |
| description | | description |
| "Maximum LSP lifetime in seconds"; | | "Maximum LSP lifetime in seconds"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set maximum LSP lifetime"; | | "Set maximum LSP lifetime"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container min-lsp-arrivaltime { | | container min-lsp-arrivaltime { |
| must "maximum-wait or initial-wait or secondary-wait"; | | must "maximum-wait or initial-wait or secondary-wait"; |
| presence "Indicates a min-lsp-arrivaltime node is configured."; | | presence "Indicates a min-lsp-arrivaltime node is configured."; |
| description | | description |
| "Set minimum arrival time of incoming LSPs"; | | "Set minimum arrival time of incoming LSPs"; |
| leaf maximum-wait { | | leaf maximum-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum delay expected to take since last LSP"; | | "Maximum delay expected to take since last LSP"; |
| } | | } |
| leaf initial-wait { | | leaf initial-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Initial delay expected to take since last LSP"; | | "Initial delay expected to take since last LSP"; |
| } | | } |
| leaf secondary-wait { | | leaf secondary-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Secondary delay expected to take since last LSP"; | | "Secondary delay expected to take since last LSP"; |
| } | | } |
| } | | } |
| container min-lsp-arrivaltime-levels { | | container min-lsp-arrivaltime-levels { |
| description | | description |
| "Set LSP arrival time for one level only"; | | "Set LSP arrival time for one level only"; |
| list level { | | list level { |
| must "maximum-wait or initial-wait or secondary-wait"; | | must "maximum-wait or initial-wait or secondary-wait"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set LSP arrival time for one level only"; | | "Set LSP arrival time for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set LSP arrival time for one level only"; | | "Set LSP arrival time for one level only"; |
| } | | } |
| leaf maximum-wait { | | leaf maximum-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum delay expected to take since last LSP"; | | "Maximum delay expected to take since last LSP"; |
| } | | } |
| leaf initial-wait { | | leaf initial-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Initial delay expected to take since last LSP"; | | "Initial delay expected to take since last LSP"; |
| } | | } |
| leaf secondary-wait { | | leaf secondary-wait { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Secondary delay expected to take since last LSP"; | | "Secondary delay expected to take since last LSP"; |
| } | | } |
| } | | } |
| } | | } |
| container lsp-mtu { | | container lsp-mtu { |
| description | | description |
| "Set maximum LSP size"; | | "Set maximum LSP size"; |
| leaf lsp-mtu-size { | | leaf lsp-mtu-size { |
| type uint32 { | | type uint32 { |
| range "128..8979" { | | range "128..8979" { |
| description | | description |
| "Max LSP size in bytes"; | | "Max LSP size in bytes"; |
| } | | } |
| } | | } |
| description | | description |
| "Set maximum LSP size"; | | "Set maximum LSP size"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set LSP size for one level only"; | | "Set LSP size for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set LSP size for one level only"; | | "Set LSP size for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set LSP size for one level only"; | | "Set LSP size for one level only"; |
| } | | } |
| leaf lsp-mtu-size { | | leaf lsp-mtu-size { |
| type uint32 { | | type uint32 { |
| range "128..8979" { | | range "128..8979" { |
| description | | description |
| "Max LSP size in bytes"; | | "Max LSP size in bytes"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set maximum LSP size"; | | "Set maximum LSP size"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container lsp-refresh-interval { | | container lsp-refresh-interval { |
| description | | description |
| "Set LSP refresh interval"; | | "Set LSP refresh interval"; |
| leaf lsp-refresh-interval-time { | | leaf lsp-refresh-interval-time { |
| type uint32 { | | type uint32 { |
| range "1..65535" { | | range "1..65535" { |
| description | | description |
| "LSP refresh time in seconds"; | | "LSP refresh time in seconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Set LSP refresh interval"; | | "Set LSP refresh interval"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set LSP refresh interval for one level only"; | | "Set LSP refresh interval for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set LSP refresh interval for one level only"; | | "Set LSP refresh interval for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set LSP refresh interval for one level only"; | | "Set LSP refresh interval for one level only"; |
| } | | } |
| leaf lsp-refresh-interval-time { | | leaf lsp-refresh-interval-time { |
| type uint32 { | | type uint32 { |
| range "1..65535" { | | range "1..65535" { |
| description | | description |
| "LSP refresh time in seconds"; | | "LSP refresh time in seconds"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set LSP refresh interval"; | | "Set LSP refresh interval"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container max-metric { | | container max-metric { |
| presence "Indicates a no-options node is configured."; | | presence "Indicates a no-options node is configured."; |
| description | | description |
| "Signal other routers to use us as transit option of last resort"; | | "Signal other routers to use us as transit option of last resort"; |
| container on-startup { | | container on-startup { |
| description | | description |
| "Set maximum metric temporarily after reboot"; | | "Set maximum metric temporarily after reboot"; |
| container advertise-maximum-metric { | | container advertise-maximum-metric { |
| must "not(../wait-for-bgp)"; | | must "not(../wait-for-bgp)"; |
| presence "Indicates a advertise-maximum-metric node is configured."; | | presence "Indicates a advertise-maximum-metric node is configured."; |
| description | | description |
| "Time in seconds to advertise maximum metric after reboot"; | | "Time in seconds to advertise maximum metric after reboot"; |
| leaf time-to-advertise { | | leaf time-to-advertise { |
| type uint32 { | | type uint32 { |
| range "5..86400" { | | range "5..86400" { |
| description | | description |
| "Time in seconds to advertise maximum metric after reboot"; | | "Time in seconds to advertise maximum metric after reboot"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Time in seconds to advertise maximum metric after reboot"; | | "Time in seconds to advertise maximum metric after reboot"; |
| } | | } |
| } | | } |
| container wait-for-bgp { | | container wait-for-bgp { |
| must "not(../advertise-maximum-metric)"; | | must "not(../advertise-maximum-metric)"; |
| presence "Indicates a wait-for-bgp node is configured."; | | presence "Indicates a wait-for-bgp node is configured."; |
| description | | description |
| "Set maximum metric on startup until BGP signalsconvergence, or timeout"; | | "Set maximum metric on startup until BGP signalsconvergence, or timeout"; |
| } | | } |
| container external { | | container external { |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "Override metric of prefixes learned from another protocol with maximum metric"; | | "Override metric of prefixes learned from another protocol with maximum metric"; |
| } | | } |
| container interlevel { | | container interlevel { |
| presence "Indicates a interlevel node is configured."; | | presence "Indicates a interlevel node is configured."; |
| description | | description |
| "Override metric of prefixes learned from another ISIS level with maximum metric"; | | "Override metric of prefixes learned from another ISIS level with maximum metric"; |
| } | | } |
| container default-route { | | container default-route { |
| presence "Indicates a default-route node is configured."; | | presence "Indicates a default-route node is configured."; |
| description | | description |
| "Override default route metric with maximum metric"; | | "Override default route metric with maximum metric"; |
| } | | } |
| container srv6-locator { | | container srv6-locator { |
| presence "Indicates a srv6-locator node is configured."; | | presence "Indicates a srv6-locator node is configured."; |
| description | | description |
| "Override segment routing ipv6 metric with maximum metric"; | | "Override segment routing ipv6 metric with maximum metric"; |
| } | | } |
| n | container te { | n | |
| presence "Indicates a te node is configured."; | | |
| description | | |
| "Apply max-metric to TE metric"; | | |
| } | | |
| container delay { | | |
| presence "Indicates a delay node is configured."; | | |
| description | | |
| "Apply max-metric to delay metric"; | | |
| } | | |
| } | | } |
| } | | } |
| container max-metric-levels { | | container max-metric-levels { |
| description | | description |
| "Set maximum metric for one level only"; | | "Set maximum metric for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set maximum metric for one level only"; | | "Set maximum metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set maximum metric for one level only"; | | "Set maximum metric for one level only"; |
| } | | } |
| container advertise-maximum-metric { | | container advertise-maximum-metric { |
| must "not(../wait-for-bgp)"; | | must "not(../wait-for-bgp)"; |
| presence "Indicates a advertise-maximum-metric node is configured."; | | presence "Indicates a advertise-maximum-metric node is configured."; |
| description | | description |
| "Time in seconds to advertise maximum metric after reboot"; | | "Time in seconds to advertise maximum metric after reboot"; |
| leaf time-to-advertise { | | leaf time-to-advertise { |
| type uint32 { | | type uint32 { |
| range "5..86400" { | | range "5..86400" { |
| description | | description |
| "Time in seconds to advertise maximum metric after reboot"; | | "Time in seconds to advertise maximum metric after reboot"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Time in seconds to advertise maximum metric after reboot"; | | "Time in seconds to advertise maximum metric after reboot"; |
| } | | } |
| } | | } |
| container wait-for-bgp { | | container wait-for-bgp { |
| must "not(../advertise-maximum-metric)"; | | must "not(../advertise-maximum-metric)"; |
| presence "Indicates a wait-for-bgp node is configured."; | | presence "Indicates a wait-for-bgp node is configured."; |
| description | | description |
| "Set maximum metric on startup until BGP signalsconvergence, or timeout"; | | "Set maximum metric on startup until BGP signalsconvergence, or timeout"; |
| } | | } |
| container external { | | container external { |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "Override metric of prefixes learned from another protocol with maximum metric"; | | "Override metric of prefixes learned from another protocol with maximum metric"; |
| } | | } |
| container interlevel { | | container interlevel { |
| presence "Indicates a interlevel node is configured."; | | presence "Indicates a interlevel node is configured."; |
| description | | description |
| "Override metric of prefixes learned from another ISIS level with maximum metric"; | | "Override metric of prefixes learned from another ISIS level with maximum metric"; |
| } | | } |
| container default-route { | | container default-route { |
| presence "Indicates a default-route node is configured."; | | presence "Indicates a default-route node is configured."; |
| description | | description |
| "Override default route metric with maximum metric"; | | "Override default route metric with maximum metric"; |
| } | | } |
| container srv6-locator { | | container srv6-locator { |
| presence "Indicates a srv6-locator node is configured."; | | presence "Indicates a srv6-locator node is configured."; |
| description | | description |
| "Override segment routing ipv6 metric with maximum metric"; | | "Override segment routing ipv6 metric with maximum metric"; |
| } | | } |
| n | container te { | n | |
| presence "Indicates a te node is configured."; | | |
| description | | |
| "Apply max-metric to TE metric"; | | |
| } | | |
| container delay { | | |
| presence "Indicates a delay node is configured."; | | |
| description | | |
| "Apply max-metric to delay metric"; | | |
| } | | |
| } | | } |
| } | | } |
| container set-overload-bit { | | container set-overload-bit { |
| presence "Indicates a set-overloaded-bit node is configured."; | | presence "Indicates a set-overloaded-bit node is configured."; |
| description | | description |
| "Signal other routers not to use us in SPF"; | | "Signal other routers not to use us in SPF"; |
| container on-startup { | | container on-startup { |
| description | | description |
| "Set overload-bit temporarily after reboot"; | | "Set overload-bit temporarily after reboot"; |
| container advertise-as-overloaded { | | container advertise-as-overloaded { |
| must "not(../wait-for-bgp)"; | | must "not(../wait-for-bgp)"; |
| presence "Indicates a advertise-as-overloaded node is configured."; | | presence "Indicates a advertise-as-overloaded node is configured."; |
| description | | description |
| "Time in seconds to advertise ourself as overloaded after reboot"; | | "Time in seconds to advertise ourself as overloaded after reboot"; |
| leaf time-to-advertise { | | leaf time-to-advertise { |
| type uint32 { | | type uint32 { |
| range "5..86400" { | | range "5..86400" { |
| description | | description |
| "Time in seconds to advertise ourself as overloaded after reboot"; | | "Time in seconds to advertise ourself as overloaded after reboot"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Time in seconds to advertise ourself as overloaded after reboot"; | | "Time in seconds to advertise ourself as overloaded after reboot"; |
| } | | } |
| } | | } |
| container wait-for-bgp { | | container wait-for-bgp { |
| must "not(../advertise-as-overloaded)"; | | must "not(../advertise-as-overloaded)"; |
| presence "Indicates a wait-for-bgp node is configured."; | | presence "Indicates a wait-for-bgp node is configured."; |
| description | | description |
| "Set overload bit on startup until BGP signals convergence, or timeout"; | | "Set overload bit on startup until BGP signals convergence, or timeout"; |
| } | | } |
| } | | } |
| container advertise { | | container advertise { |
| description | | description |
| "If overload-bit set advertise the following types of IP prefixes"; | | "If overload-bit set advertise the following types of IP prefixes"; |
| container external { | | container external { |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "If overload-bit set advertise IP prefixes learned from other protocols"; | | "If overload-bit set advertise IP prefixes learned from other protocols"; |
| } | | } |
| container interlevel { | | container interlevel { |
| presence "Indicates a interlevel node is configured."; | | presence "Indicates a interlevel node is configured."; |
| description | | description |
| "If overload-bit set advertise IP prefixes learned from another ISIS level"; | | "If overload-bit set advertise IP prefixes learned from another ISIS level"; |
| } | | } |
| } | | } |
| } | | } |
| container set-overload-bit-levels { | | container set-overload-bit-levels { |
| description | | description |
| "Set overload-bit for one level only"; | | "Set overload-bit for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set overload-bit for one level only"; | | "Set overload-bit for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set overload-bit for one level only"; | | "Set overload-bit for one level only"; |
| } | | } |
| container on-startup { | | container on-startup { |
| description | | description |
| "Set overload-bit temporarily after reboot"; | | "Set overload-bit temporarily after reboot"; |
| container advertise-as-overloaded { | | container advertise-as-overloaded { |
| must "not(../wait-for-bgp)"; | | must "not(../wait-for-bgp)"; |
| presence "Indicates a advertise-as-overloaded node is configured."; | | presence "Indicates a advertise-as-overloaded node is configured."; |
| description | | description |
| "Time in seconds to advertise ourself as overloaded after reboot"; | | "Time in seconds to advertise ourself as overloaded after reboot"; |
| leaf time-to-advertise { | | leaf time-to-advertise { |
| type uint32 { | | type uint32 { |
| range "5..86400" { | | range "5..86400" { |
| description | | description |
| "Time in seconds to advertise ourself as overloaded after reboot"; | | "Time in seconds to advertise ourself as overloaded after reboot"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Time in seconds to advertise ourself as overloaded after reboot"; | | "Time in seconds to advertise ourself as overloaded after reboot"; |
| } | | } |
| } | | } |
| container wait-for-bgp { | | container wait-for-bgp { |
| must "not(../advertise-as-overloaded)"; | | must "not(../advertise-as-overloaded)"; |
| presence "Indicates a wait-for-bgp node is configured."; | | presence "Indicates a wait-for-bgp node is configured."; |
| description | | description |
| "Set overload bit on startup until BGP signals convergence, or timeout"; | | "Set overload bit on startup until BGP signals convergence, or timeout"; |
| } | | } |
| } | | } |
| container advertise { | | container advertise { |
| description | | description |
| "If overload-bit set advertise the following types of IP prefixes"; | | "If overload-bit set advertise the following types of IP prefixes"; |
| container external { | | container external { |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "If overload-bit set advertise IP prefixes learned from other protocols"; | | "If overload-bit set advertise IP prefixes learned from other protocols"; |
| } | | } |
| container interlevel { | | container interlevel { |
| presence "Indicates a interlevel node is configured."; | | presence "Indicates a interlevel node is configured."; |
| description | | description |
| "If overload-bit set advertise IP prefixes learned from another ISIS level"; | | "If overload-bit set advertise IP prefixes learned from another ISIS level"; |
| } | | } |
| } | | } |
| n | } | n | |
| } | | |
| container oor-set-overload-bit { | | |
| description | | |
| "Overload-bit setting when Out-Of-Resource (OOR)"; | | |
| container disable { | | |
| presence "Indicates a disable node is configured."; | | |
| description | | |
| "Disable setting of overload-bit when OOR. ISIS will continue to participate in forwarding but its decision will be based on an incomplete link-state database. It may lead to routing loops and other forwarding failures. NOT recommended."; | | |
| } | | } |
| } | | } |
| container nets { | | container nets { |
| description | | description |
| "A Network Entity Title (NET) for this process"; | | "A Network Entity Title (NET) for this process"; |
| list net { | | list net { |
| key "net-id"; | | key "net-id"; |
| description | | description |
| "A Network Entity Title (NET) for this process"; | | "A Network Entity Title (NET) for this process"; |
| leaf net-id { | | leaf net-id { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "NET (XX.XXXX. ... .XXXX.XX)"; | | "NET (XX.XXXX. ... .XXXX.XX)"; |
| } | | } |
| } | | } |
| description | | description |
| "A Network Entity Title (NET) for this process"; | | "A Network Entity Title (NET) for this process"; |
| } | | } |
| } | | } |
| } | | } |
| container link-groups { | | container link-groups { |
| description | | description |
| "Link Group"; | | "Link Group"; |
| list link-group { | | list link-group { |
| key "link-group-name"; | | key "link-group-name"; |
| description | | description |
| "Link Group"; | | "Link Group"; |
| leaf link-group-name { | | leaf link-group-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "link group name"; | | "link group name"; |
| } | | } |
| } | | } |
| description | | description |
| "Link Group"; | | "Link Group"; |
| } | | } |
| leaf minimum-members { | | leaf minimum-members { |
| type uint32 { | | type uint32 { |
| range "2..64" { | | range "2..64" { |
| description | | description |
| "count"; | | "count"; |
| } | | } |
| } | | } |
| description | | description |
| "Minimum number of members in the link group"; | | "Minimum number of members in the link group"; |
| } | | } |
| leaf revert-members { | | leaf revert-members { |
| type uint32 { | | type uint32 { |
| range "2..64" { | | range "2..64" { |
| description | | description |
| "count"; | | "count"; |
| } | | } |
| } | | } |
| description | | description |
| "Number of members after which to revert in the link group"; | | "Number of members after which to revert in the link group"; |
| } | | } |
| container metric-offset { | | container metric-offset { |
| description | | description |
| "Configure the metric offset for link group"; | | "Configure the metric offset for link group"; |
| container maximum { | | container maximum { |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Maximum wide metric offset. All routers will exclude this link from their SPF"; | | "Maximum wide metric offset. All routers will exclude this link from their SPF"; |
| } | | } |
| leaf default-metric-offset { | | leaf default-metric-offset { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Default metric offset: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric offset: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Default metric offset: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric offset: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container nsf { | | container nsf { |
| description | | description |
| "Allow non-stop forwarding (NSF) on next restart"; | | "Allow non-stop forwarding (NSF) on next restart"; |
| leaf lifetime { | | leaf lifetime { |
| type uint32 { | | type uint32 { |
| range "5..300" { | | range "5..300" { |
| description | | description |
| "seconds"; | | "seconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum route lifetime following restart (seconds)"; | | "Maximum route lifetime following restart (seconds)"; |
| } | | } |
| leaf interface-timer { | | leaf interface-timer { |
| type uint32 { | | type uint32 { |
| range "1..20" { | | range "1..20" { |
| description | | description |
| "seconds"; | | "seconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Timer used to wait for a restart ACK (seconds)"; | | "Timer used to wait for a restart ACK (seconds)"; |
| } | | } |
| leaf interface-expires { | | leaf interface-expires { |
| type uint32 { | | type uint32 { |
| range "1..10" { | | range "1..10" { |
| description | | description |
| "expiry count"; | | "expiry count"; |
| } | | } |
| } | | } |
| description | | description |
| "# of times T1 can expire waiting for the restart ACK"; | | "# of times T1 can expire waiting for the restart ACK"; |
| } | | } |
| container cisco { | | container cisco { |
| must "not(../ietf)"; | | must "not(../ietf)"; |
| presence "Indicates a cisco node is configured."; | | presence "Indicates a cisco node is configured."; |
| description | | description |
| "Cisco Proprietary NSF restart"; | | "Cisco Proprietary NSF restart"; |
| } | | } |
| container ietf { | | container ietf { |
| must "not(../cisco)"; | | must "not(../cisco)"; |
| presence "Indicates a ietf node is configured."; | | presence "Indicates a ietf node is configured."; |
| description | | description |
| "IETF NSF restar"; | | "IETF NSF restar"; |
| } | | } |
| } | | } |
| n | container hello-padding { | n | |
| presence "Indicates a hello-padding node is configured."; | | |
| description | | |
| "Add padding to IS-IS hello packets"; | | |
| container disable { | | |
| must "not(../sometimes)"; | | |
| presence "Indicates a disable node is configured."; | | |
| description | | |
| "Disable hello-padding"; | | |
| } | | |
| container sometimes { | | |
| must "not(../disable)"; | | |
| presence "Indicates a sometimes node is configured."; | | |
| description | | |
| "Enable hello-padding during adjacency formation only"; | | |
| } | | |
| } | | |
| container trace { | | container trace { |
| description | | description |
| "Set trace buffer parameters"; | | "Set trace buffer parameters"; |
| leaf mode { | | leaf mode { |
| type enumeration { | | type enumeration { |
| enum "off" { | | enum "off" { |
| value 0; | | value 0; |
| description | | description |
| "No tracing"; | | "No tracing"; |
| } | | } |
| enum "basic" { | | enum "basic" { |
| value 1; | | value 1; |
| description | | description |
| "Basic tracing (less overhead)"; | | "Basic tracing (less overhead)"; |
| } | | } |
| enum "enhanced" { | | enum "enhanced" { |
| value 2; | | value 2; |
| description | | description |
| "Enhanced tracing (more overhead)"; | | "Enhanced tracing (more overhead)"; |
| } | | } |
| } | | } |
| description | | description |
| "Set tracing type"; | | "Set tracing type"; |
| } | | } |
| leaf detailed { | | leaf detailed { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for detailed traces"; | | "Buffer size for detailed traces"; |
| } | | } |
| leaf standard { | | leaf standard { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for standard traces"; | | "Buffer size for standard traces"; |
| } | | } |
| leaf severe { | | leaf severe { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for severe traces"; | | "Buffer size for severe traces"; |
| } | | } |
| leaf hello { | | leaf hello { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for hello traces"; | | "Buffer size for hello traces"; |
| } | | } |
| leaf startup { | | leaf startup { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for startup traces"; | | "Buffer size for startup traces"; |
| } | | } |
| leaf config { | | leaf config { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for config traces"; | | "Buffer size for config traces"; |
| } | | } |
| leaf lspgen { | | leaf lspgen { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for lspgen traces"; | | "Buffer size for lspgen traces"; |
| } | | } |
| leaf adj { | | leaf adj { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for adj traces"; | | "Buffer size for adj traces"; |
| } | | } |
| leaf spf { | | leaf spf { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for spf traces"; | | "Buffer size for spf traces"; |
| } | | } |
| leaf sr { | | leaf sr { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for sr traces"; | | "Buffer size for sr traces"; |
| } | | } |
| leaf rib { | | leaf rib { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for rib traces"; | | "Buffer size for rib traces"; |
| } | | } |
| leaf te { | | leaf te { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for te traces"; | | "Buffer size for te traces"; |
| } | | } |
| leaf update { | | leaf update { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for update traces"; | | "Buffer size for update traces"; |
| } | | } |
| leaf pkt { | | leaf pkt { |
| type uint32 { | | type uint32 { |
| range "1..1000000" { | | range "1..1000000" { |
| description | | description |
| "Maximum number of trace entries"; | | "Maximum number of trace entries"; |
| } | | } |
| } | | } |
| description | | description |
| "Buffer size for pkt traces"; | | "Buffer size for pkt traces"; |
| } | | } |
| } | | } |
| leaf triggers { | | leaf triggers { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "<adj>/<LSP>/<routes>"; | | "<adj>/<LSP>/<routes>"; |
| } | | } |
| } | | } |
| description | | description |
| "Set logging triggers for performance testing"; | | "Set logging triggers for performance testing"; |
| } | | } |
| container address-families { | | container address-families { |
| description | | description |
| "Enter the IS-IS address-family configuration submode"; | | "Enter the IS-IS address-family configuration submode"; |
| list address-family { | | list address-family { |
| key "af-name saf-name"; | | key "af-name saf-name"; |
| description | | description |
| "IS-IS address family"; | | "IS-IS address family"; |
| leaf af-name { | | leaf af-name { |
| type Isis-af-name; | | type Isis-af-name; |
| description | | description |
| "Address family name"; | | "Address family name"; |
| } | | } |
| leaf saf-name { | | leaf saf-name { |
| type Isis-saf-name; | | type Isis-saf-name; |
| description | | description |
| "Sub address family name"; | | "Sub address family name"; |
| } | | } |
| n | container prefix-unreachable { | n | |
| presence "Indicates a prefix-unreachable node is configured."; | | |
| description | | |
| "Prefix Unreachablity"; | | |
| leaf adv-maximum { | | |
| type uint32 { | | |
| range "1..65535" { | | |
| description | | |
| "Number of prefix-unreachable advertisements"; | | |
| } | | |
| } | | |
| description | | |
| "Maximum number of prefix-unreachable advertisements"; | | |
| } | | |
| leaf adv-lifetime { | | |
| type uint32 { | | |
| range "30..65535" { | | |
| description | | |
| "Lifetime value"; | | |
| } | | |
| } | | |
| description | | |
| "Lifetime of the prefix-unreachable advertisements"; | | |
| } | | |
| leaf adv-metric { | | |
| type uint32 { | | |
| range "4261412865..4294967294" { | | |
| description | | |
| "Metric value"; | | |
| } | | |
| } | | |
| description | | |
| "Metric of the prefix-unreachable advertisements"; | | |
| } | | |
| container rx-process-enable { | | |
| presence "Indicates a rx-process-enable node is configured."; | | |
| description | | |
| "Enable processing of received prefix-unreachable advertisements"; | | |
| } | | |
| } | | |
| container partition-detect { | | |
| presence "Indicates a partition-detect node is configured."; | | |
| description | | |
| "Detect area or domain partition"; | | |
| container abr-track-items { | | |
| description | | |
| "Configure ABR track-items"; | | |
| list track { | | |
| key "address"; | | |
| description | | |
| "Track ABR reachability"; | | |
| leaf address { | | |
| type string; | | |
| description | | |
| "ABR address"; | | |
| } | | |
| } | | |
| } | | |
| container asbr-track-items { | | |
| description | | |
| "Configure ASBR track-items"; | | |
| list track { | | |
| key "address"; | | |
| description | | |
| "Track ASBR reachability"; | | |
| leaf address { | | |
| type string; | | |
| description | | |
| "Internal ASBR address"; | | |
| } | | |
| leaf external-address { | | |
| type string; | | |
| mandatory true; | | |
| description | | |
| "External ASBR address"; | | |
| } | | |
| } | | |
| } | | |
| } | | |
| container default-information { | | container default-information { |
| description | | description |
| "Control distribution of default information"; | | "Control distribution of default information"; |
| container originate { | | container originate { |
| presence "Indicates a originate node is configured."; | | presence "Indicates a originate node is configured."; |
| description | | description |
| "Distribute a default route"; | | "Distribute a default route"; |
| container external { | | container external { |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "Originate default prefix as an external route"; | | "Originate default prefix as an external route"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| } | | } |
| } | | } |
| container segment-routing { | | container segment-routing { |
| description | | description |
| "Enable Segment Routing"; | | "Enable Segment Routing"; |
| container mpls { | | container mpls { |
| description | | description |
| "Enable Segment Routing using MPLS encapsulation"; | | "Enable Segment Routing using MPLS encapsulation"; |
| leaf sr-prefer { | | leaf sr-prefer { |
| when "../../../saf-name = 'unicast'"; | | when "../../../saf-name = 'unicast'"; |
| type boolean; | | type boolean; |
| description | | description |
| "Prefer segment routing labels over LDP labels"; | | "Prefer segment routing labels over LDP labels"; |
| } | | } |
| container unlabeled { | | container unlabeled { |
| when "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'"; | | when "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'"; |
| description | | description |
| "Options for prefixes without a segment-routing label"; | | "Options for prefixes without a segment-routing label"; |
| container protection { | | container protection { |
| description | | description |
| "TI-LFA and microloop protection"; | | "TI-LFA and microloop protection"; |
| leaf prefix-list { | | leaf prefix-list { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Prefix-list name"; | | "Prefix-list name"; |
| } | | } |
| } | | } |
| must "not(../route-policy or ../disable)"; | | must "not(../route-policy or ../disable)"; |
| description | | description |
| "Enable TI-LFA and microloop protection based on a prefix list"; | | "Enable TI-LFA and microloop protection based on a prefix list"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| must "not(../prefix-list or ../disable)"; | | must "not(../prefix-list or ../disable)"; |
| description | | description |
| "Enable TI-LFA and microloop protection based on a route policy"; | | "Enable TI-LFA and microloop protection based on a route policy"; |
| } | | } |
| container disable { | | container disable { |
| must "not(../prefix-list or ../route-policy)"; | | must "not(../prefix-list or ../route-policy)"; |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable TI-LFA and microloop protection"; | | "Disable TI-LFA and microloop protection"; |
| } | | } |
| } | | } |
| } | | } |
| container connected-prefix-sid-map { | | container connected-prefix-sid-map { |
| presence "Indicates a connected-prefix-sid-map node is configured."; | | presence "Indicates a connected-prefix-sid-map node is configured."; |
| description | | description |
| "Enter connected prefix sid map submode"; | | "Enter connected prefix sid map submode"; |
| container prefixes { | | container prefixes { |
| when "../../../../saf-name = 'unicast'"; | | when "../../../../saf-name = 'unicast'"; |
| description | | description |
| "Specify prefix associated with this Prefix Segement ID"; | | "Specify prefix associated with this Prefix Segement ID"; |
| list prefix { | | list prefix { |
| must "index or absolute"; | | must "index or absolute"; |
| key "address-prefix"; | | key "address-prefix"; |
| description | | description |
| "Specify prefix associated with this Prefix Segement ID"; | | "Specify prefix associated with this Prefix Segement ID"; |
| leaf address-prefix { | | leaf address-prefix { |
| type inet:ip-prefix; | | type inet:ip-prefix; |
| description | | description |
| "Specify prefix associated with this Prefix Segement ID"; | | "Specify prefix associated with this Prefix Segement ID"; |
| } | | } |
| container index { | | container index { |
| must "not(../absolute)"; | | must "not(../absolute)"; |
| presence "Indicates a index node is configured."; | | presence "Indicates a index node is configured."; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| leaf index-id { | | leaf index-id { |
| type uint32 { | | type uint32 { |
| range "0..1048575" { | | range "0..1048575" { |
| description | | description |
| "The Prefix Segment ID index value"; | | "The Prefix Segment ID index value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| } | | } |
| } | | } |
| container absolute { | | container absolute { |
| must "not(../index)"; | | must "not(../index)"; |
| presence "Indicates a absolute node is configured."; | | presence "Indicates a absolute node is configured."; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| leaf absolute-value { | | leaf absolute-value { |
| type uint32 { | | type uint32 { |
| range "16000..1048575" { | | range "16000..1048575" { |
| description | | description |
| "The Prefix Segment ID absolute value"; | | "The Prefix Segment ID absolute value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| } | | } |
| } | | } |
| n | leaf interface { | n | |
| type xr:Interface-name; | | |
| description | | |
| "Specify the interface associated with the prefix sid"; | | |
| } | | |
| container php-disable { | | |
| presence "Indicates a php-disable node is configured."; | | |
| description | | |
| "Disable Penultimate Hop Popping"; | | |
| } | | |
| container explicit-null { | | container explicit-null { |
| presence "Indicates a explicit-null node is configured."; | | presence "Indicates a explicit-null node is configured."; |
| description | | description |
| "Upstream neighbor must replace prefix-sid with explicit null label"; | | "Upstream neighbor must replace prefix-sid with explicit null label"; |
| } | | } |
| } | | } |
| } | | } |
| container flex-algo { | | container flex-algo { |
| when "../../../../saf-name = 'unicast'"; | | when "../../../../saf-name = 'unicast'"; |
| description | | description |
| "Specify the custom flex-algo algorithm to use"; | | "Specify the custom flex-algo algorithm to use"; |
| list prefix { | | list prefix { |
| must "index or absolute"; | | must "index or absolute"; |
| key "address-prefix flex-algo"; | | key "address-prefix flex-algo"; |
| description | | description |
| "Specify prefix associated with this Prefix Segement ID"; | | "Specify prefix associated with this Prefix Segement ID"; |
| leaf address-prefix { | | leaf address-prefix { |
| type inet:ip-prefix; | | type inet:ip-prefix; |
| description | | description |
| "Specify prefix associated with this Prefix Segement ID"; | | "Specify prefix associated with this Prefix Segement ID"; |
| } | | } |
| leaf flex-algo { | | leaf flex-algo { |
| type uint32 { | | type uint32 { |
| range "128..255" { | | range "128..255" { |
| description | | description |
| "Algo number"; | | "Algo number"; |
| } | | } |
| } | | } |
| description | | description |
| "Specify the custom flex-algo algorithm to use"; | | "Specify the custom flex-algo algorithm to use"; |
| } | | } |
| container index { | | container index { |
| must "not(../absolute)"; | | must "not(../absolute)"; |
| presence "Indicates a index node is configured."; | | presence "Indicates a index node is configured."; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| leaf index-id { | | leaf index-id { |
| type uint32 { | | type uint32 { |
| range "0..1048575" { | | range "0..1048575" { |
| description | | description |
| "The Prefix Segment ID index value"; | | "The Prefix Segment ID index value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| } | | } |
| } | | } |
| container absolute { | | container absolute { |
| must "not(../index)"; | | must "not(../index)"; |
| presence "Indicates a absolute node is configured."; | | presence "Indicates a absolute node is configured."; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| leaf absolute-value { | | leaf absolute-value { |
| type uint32 { | | type uint32 { |
| range "16000..1048575" { | | range "16000..1048575" { |
| description | | description |
| "The Prefix Segment ID absolute value"; | | "The Prefix Segment ID absolute value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| } | | } |
| } | | } |
| n | leaf interface { | n | |
| type xr:Interface-name; | | |
| description | | |
| "Specify the interface associated with the prefix sid"; | | |
| } | | |
| container php-disable { | | |
| presence "Indicates a php-disable node is configured."; | | |
| description | | |
| "Disable Penultimate Hop Popping"; | | |
| } | | |
| container explicit-null { | | container explicit-null { |
| presence "Indicates a explicit-null node is configured."; | | presence "Indicates a explicit-null node is configured."; |
| description | | description |
| "Upstream neighbor must replace prefix-sid with explicit null label"; | | "Upstream neighbor must replace prefix-sid with explicit null label"; |
| } | | } |
| } | | } |
| } | | } |
| container strict-spf { | | container strict-spf { |
| when "../../../../saf-name = 'unicast'"; | | when "../../../../saf-name = 'unicast'"; |
| description | | description |
| "Use strict-spf"; | | "Use strict-spf"; |
| list prefix { | | list prefix { |
| must "index or absolute"; | | must "index or absolute"; |
| key "address-prefix"; | | key "address-prefix"; |
| description | | description |
| "Specify prefix associated with this Prefix Segement ID"; | | "Specify prefix associated with this Prefix Segement ID"; |
| leaf address-prefix { | | leaf address-prefix { |
| type inet:ip-prefix; | | type inet:ip-prefix; |
| description | | description |
| "Specify prefix associated with this Prefix Segement ID"; | | "Specify prefix associated with this Prefix Segement ID"; |
| } | | } |
| container index { | | container index { |
| must "not(../absolute)"; | | must "not(../absolute)"; |
| presence "Indicates a index node is configured."; | | presence "Indicates a index node is configured."; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| leaf index-id { | | leaf index-id { |
| type uint32 { | | type uint32 { |
| range "0..1048575" { | | range "0..1048575" { |
| description | | description |
| "The Prefix Segment ID index value"; | | "The Prefix Segment ID index value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| } | | } |
| } | | } |
| container absolute { | | container absolute { |
| must "not(../index)"; | | must "not(../index)"; |
| presence "Indicates a absolute node is configured."; | | presence "Indicates a absolute node is configured."; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| leaf absolute-value { | | leaf absolute-value { |
| type uint32 { | | type uint32 { |
| range "16000..1048575" { | | range "16000..1048575" { |
| description | | description |
| "The Prefix Segment ID absolute value"; | | "The Prefix Segment ID absolute value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| } | | } |
| } | | } |
| n | leaf interface { | n | |
| type xr:Interface-name; | | |
| description | | |
| "Specify the interface associated with the prefix sid"; | | |
| } | | |
| container php-disable { | | |
| presence "Indicates a php-disable node is configured."; | | |
| description | | |
| "Disable Penultimate Hop Popping"; | | |
| } | | |
| container explicit-null { | | container explicit-null { |
| presence "Indicates a explicit-null node is configured."; | | presence "Indicates a explicit-null node is configured."; |
| description | | description |
| "Upstream neighbor must replace prefix-sid with explicit null label"; | | "Upstream neighbor must replace prefix-sid with explicit null label"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container prefix-sid-map { | | container prefix-sid-map { |
| when "../../saf-name = 'unicast'"; | | when "../../saf-name = 'unicast'"; |
| description | | description |
| "Enable prefix-sid-map"; | | "Enable prefix-sid-map"; |
| container receive { | | container receive { |
| presence "Indicates a receive node is configured."; | | presence "Indicates a receive node is configured."; |
| description | | description |
| "Use remote mapping server advertisements"; | | "Use remote mapping server advertisements"; |
| container disable { | | container disable { |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable the usage of remote mapping server advertisements"; | | "Disable the usage of remote mapping server advertisements"; |
| } | | } |
| } | | } |
| container advertise-local { | | container advertise-local { |
| presence "Indicates a advertise-local node is configured."; | | presence "Indicates a advertise-local node is configured."; |
| description | | description |
| "Advertise active local prefix-SID mappings"; | | "Advertise active local prefix-SID mappings"; |
| container domain-wide { | | container domain-wide { |
| presence "Indicates a domain-wide node is configured."; | | presence "Indicates a domain-wide node is configured."; |
| description | | description |
| "Domain wide prefix-SID mappings"; | | "Domain wide prefix-SID mappings"; |
| } | | } |
| } | | } |
| } | | } |
| container bundle-member-adj-sid { | | container bundle-member-adj-sid { |
| when "../../saf-name = 'unicast'"; | | when "../../saf-name = 'unicast'"; |
| presence "Indicates a bundle-member-adj-sid node is configured."; | | presence "Indicates a bundle-member-adj-sid node is configured."; |
| description | | description |
| "Enable per bundle member adjacency SID"; | | "Enable per bundle member adjacency SID"; |
| n | } | n | |
| container labeled-only { | | |
| when "../../saf-name = 'unicast'"; | | |
| presence "Indicates a labeled-only node is configured."; | | |
| description | | |
| "Only install SR labeled paths"; | | |
| } | | } |
| leaf protected-adjacency-sid-delay { | | leaf protected-adjacency-sid-delay { |
| when "../../saf-name = 'unicast'"; | | when "../../saf-name = 'unicast'"; |
| type uint32 { | | type uint32 { |
| range "30..3600" { | | range "30..3600" { |
| description | | description |
| "seconds"; | | "seconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Protected Adjacency SID deletion delay (seconds)"; | | "Protected Adjacency SID deletion delay (seconds)"; |
| } | | } |
| container srv6 { | | container srv6 { |
| when "../../af-name = 'ipv6' and ../../saf-name = 'unicast'"; | | when "../../af-name = 'ipv6' and ../../saf-name = 'unicast'"; |
| presence "Indicates a srv6 node is configured."; | | presence "Indicates a srv6 node is configured."; |
| description | | description |
| "Enable SRv6"; | | "Enable SRv6"; |
| container locators { | | container locators { |
| description | | description |
| "Enter SRv6 Locator submode"; | | "Enter SRv6 Locator submode"; |
| list locator { | | list locator { |
| key "locator-name"; | | key "locator-name"; |
| description | | description |
| "Enter SRv6 Locator submode"; | | "Enter SRv6 Locator submode"; |
| leaf locator-name { | | leaf locator-name { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..59" { | | length "1..59" { |
| description | | description |
| "Locator name"; | | "Locator name"; |
| } | | } |
| } | | } |
| description | | description |
| "Enter SRv6 Locator submode"; | | "Enter SRv6 Locator submode"; |
| } | | } |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Advertise the locator only in the specified level"; | | "Advertise the locator only in the specified level"; |
| } | | } |
| n | container metric { | n | |
| description | | |
| "Advertise the locator metric for a given level"; | | |
| leaf srv6-locator-metric { | | |
| type uint32 { | | |
| range "1..16777214" { | | |
| description | | |
| "Srv6 locator metric"; | | |
| } | | |
| } | | |
| description | | |
| "Srv6 locator metric"; | | |
| } | | |
| container levels { | | |
| description | | |
| "Set Metric for one level only"; | | |
| list level { | | |
| must "srv6-locator-metric"; | | |
| key "level-id"; | | |
| description | | |
| "Set Metric for one level only"; | | |
| leaf level-id { | | |
| type uint32 { | | |
| range "1..2" { | | |
| description | | |
| "Level"; | | |
| } | | |
| } | | |
| description | | |
| "Set Metric for one level only"; | | |
| } | | |
| leaf srv6-locator-metric { | | |
| type uint32 { | | |
| range "1..16777214" { | | |
| description | | |
| "Srv6 locator metric"; | | |
| } | | |
| } | | |
| description | | |
| "Srv6 locator metric"; | | |
| } | | |
| } | | |
| } | | |
| } | | |
| container tag { | | |
| description | | |
| "Advertise the locator tag for a given level"; | | |
| leaf srv6-locator-tag { | | |
| type uint32 { | | |
| range "1..4294967295" { | | |
| description | | |
| "Srv6 locator tag"; | | |
| } | | |
| } | | |
| description | | |
| "Srv6 locator tag"; | | |
| } | | |
| container levels { | | |
| description | | |
| "Set Tag for one level only"; | | |
| list level { | | |
| must "srv6-locator-tag"; | | |
| key "level-id"; | | |
| description | | |
| "Set Tag for one level only"; | | |
| leaf level-id { | | |
| type uint32 { | | |
| range "1..2" { | | |
| description | | |
| "Level"; | | |
| } | | |
| } | | |
| description | | |
| "Set Tag for one level only"; | | |
| } | | |
| leaf srv6-locator-tag { | | |
| type uint32 { | | |
| range "1..4294967295" { | | |
| description | | |
| "Srv6 locator tag"; | | |
| } | | |
| } | | |
| description | | |
| "Srv6 locator tag"; | | |
| } | | |
| } | | |
| } | | |
| } | | |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container distance { | | container distance { |
| description | | description |
| "Configure IS-IS administrative distances"; | | "Configure IS-IS administrative distances"; |
| leaf global-administrative-distance { | | leaf global-administrative-distance { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Administrative distance"; | | "Administrative distance"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure IS-IS administrative distances"; | | "Configure IS-IS administrative distances"; |
| } | | } |
| container route-sources { | | container route-sources { |
| description | | description |
| "Route source for this distance"; | | "Route source for this distance"; |
| list route-source { | | list route-source { |
| key "address-prefix"; | | key "address-prefix"; |
| description | | description |
| "Route source for this distance"; | | "Route source for this distance"; |
| leaf address-prefix { | | leaf address-prefix { |
| type inet:ip-prefix; | | type inet:ip-prefix; |
| description | | description |
| "Route source for this distance"; | | "Route source for this distance"; |
| } | | } |
| leaf administrative-distance { | | leaf administrative-distance { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Administrative distance"; | | "Administrative distance"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure IS-IS administrative distances"; | | "Configure IS-IS administrative distances"; |
| } | | } |
| leaf prefix-access-list { | | leaf prefix-access-list { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Prefix-list or access-list to filter routes for this distance"; | | "Prefix-list or access-list to filter routes for this distance"; |
| } | | } |
| } | | } |
| description | | description |
| "Prefix-list or access-list to filter routes for this distance"; | | "Prefix-list or access-list to filter routes for this distance"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container distribute-list { | | container distribute-list { |
| description | | description |
| "Filter routes sent to the RIB"; | | "Filter routes sent to the RIB"; |
| leaf prefix-list { | | leaf prefix-list { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Prefix-list name"; | | "Prefix-list name"; |
| } | | } |
| } | | } |
| description | | description |
| "Filter routes based on a prefix list"; | | "Filter routes based on a prefix list"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Filter routes based on a route policy"; | | "Filter routes based on a route policy"; |
| } | | } |
| n | container ip-only { | n | |
| description | | |
| "Filter routes sent to the ip-only RIB"; | | |
| leaf prefix-list { | | |
| type xr:Cisco-ios-xr-string { | | |
| length "1..1024" { | | |
| description | | |
| "Prefix-list name"; | | |
| } | | |
| } | | |
| description | | |
| "Filter routes based on a prefix list"; | | |
| } | | |
| leaf route-policy { | | |
| type xr:Route-policy-name; | | |
| description | | |
| "Filter routes based on a route policy"; | | |
| } | | |
| } | | |
| } | | } |
| container redistribute { | | container redistribute { |
| description | | description |
| "Redistribute information from another routing protocol"; | | "Redistribute information from another routing protocol"; |
| container connected { | | container connected { |
| presence "Indicates a connected node is configured."; | | presence "Indicates a connected node is configured."; |
| description | | description |
| "Connected routes"; | | "Connected routes"; |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-1) and not(../level-2)"; | | must "not(../level-1) and not(../level-2)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| list ospf { | | list ospf { |
| when "../../af-name = 'ipv4'"; | | when "../../af-name = 'ipv4'"; |
| key "process-id"; | | key "process-id"; |
| description | | description |
| "Open Shortest Path First (OSPF)"; | | "Open Shortest Path First (OSPF)"; |
| leaf process-id { | | leaf process-id { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "OSPF process ID"; | | "OSPF process ID"; |
| } | | } |
| } | | } |
| description | | description |
| "Open Shortest Path First (OSPF)"; | | "Open Shortest Path First (OSPF)"; |
| } | | } |
| container match { | | container match { |
| description | | description |
| "Redistribution of OSPF routes"; | | "Redistribution of OSPF routes"; |
| container internal { | | container internal { |
| must "not(../external or ../nssa-external)"; | | must "not(../external or ../nssa-external)"; |
| presence "Indicates a internal node is configured."; | | presence "Indicates a internal node is configured."; |
| description | | description |
| "Redistribute OSPF internal routes"; | | "Redistribute OSPF internal routes"; |
| } | | } |
| container external { | | container external { |
| must "not(../internal or ../nssa-external)"; | | must "not(../internal or ../nssa-external)"; |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "Redistribute OSPF external routes"; | | "Redistribute OSPF external routes"; |
| } | | } |
| container nssa-external { | | container nssa-external { |
| must "not(../internal or ../external)"; | | must "not(../internal or ../external)"; |
| presence "Indicates a nssa-external node is configured."; | | presence "Indicates a nssa-external node is configured."; |
| description | | description |
| "Redistribute OSPF NSSA external routes"; | | "Redistribute OSPF NSSA external routes"; |
| } | | } |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-1) and not(../level-2)"; | | must "not(../level-1) and not(../level-2)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| list ospfv3 { | | list ospfv3 { |
| when "../../af-name = 'ipv6'"; | | when "../../af-name = 'ipv6'"; |
| key "process-id"; | | key "process-id"; |
| description | | description |
| "Open Shortest Path First (OSPFv3)"; | | "Open Shortest Path First (OSPFv3)"; |
| leaf process-id { | | leaf process-id { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "OSPF process ID"; | | "OSPF process ID"; |
| } | | } |
| } | | } |
| description | | description |
| "Open Shortest Path First (OSPFv3)"; | | "Open Shortest Path First (OSPFv3)"; |
| } | | } |
| container match { | | container match { |
| description | | description |
| "Redistribution of OSPF routes"; | | "Redistribution of OSPF routes"; |
| container internal { | | container internal { |
| must "not(../external or ../nssa-external)"; | | must "not(../external or ../nssa-external)"; |
| presence "Indicates a internal node is configured."; | | presence "Indicates a internal node is configured."; |
| description | | description |
| "Redistribute OSPF internal routes"; | | "Redistribute OSPF internal routes"; |
| } | | } |
| container external { | | container external { |
| must "not(../internal or ../nssa-external)"; | | must "not(../internal or ../nssa-external)"; |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "Redistribute OSPF external routes"; | | "Redistribute OSPF external routes"; |
| } | | } |
| container nssa-external { | | container nssa-external { |
| must "not(../internal or ../external)"; | | must "not(../internal or ../external)"; |
| presence "Indicates a nssa-external node is configured."; | | presence "Indicates a nssa-external node is configured."; |
| description | | description |
| "Redistribute OSPF NSSA external routes"; | | "Redistribute OSPF NSSA external routes"; |
| } | | } |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-1) and not(../level-2)"; | | must "not(../level-1) and not(../level-2)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| container static { | | container static { |
| presence "Indicates a static node is configured."; | | presence "Indicates a static node is configured."; |
| description | | description |
| "Static routes"; | | "Static routes"; |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| container subscriber { | | container subscriber { |
| presence "Indicates a subscriber node is configured."; | | presence "Indicates a subscriber node is configured."; |
| description | | description |
| "Subscriber routes"; | | "Subscriber routes"; |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| container rip { | | container rip { |
| presence "Indicates a rip node is configured."; | | presence "Indicates a rip node is configured."; |
| description | | description |
| "RIP routes"; | | "RIP routes"; |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| container mobile { | | container mobile { |
| presence "Indicates a mobile node is configured."; | | presence "Indicates a mobile node is configured."; |
| description | | description |
| "Mobile routes"; | | "Mobile routes"; |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| container applications { | | container applications { |
| description | | description |
| "Application routes"; | | "Application routes"; |
| list application { | | list application { |
| key "application-name"; | | key "application-name"; |
| description | | description |
| "Application routes"; | | "Application routes"; |
| leaf application-name { | | leaf application-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "OnePK application name"; | | "OnePK application name"; |
| } | | } |
| } | | } |
| description | | description |
| "Application routes"; | | "Application routes"; |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| } | | } |
| list isis { | | list isis { |
| key "instance-id"; | | key "instance-id"; |
| description | | description |
| "IS-IS"; | | "IS-IS"; |
| leaf instance-id { | | leaf instance-id { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "IS-IS instance identifier"; | | "IS-IS instance identifier"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS"; | | "IS-IS"; |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| container down-flag-clear { | | container down-flag-clear { |
| presence "Indicates a down-flag-clear node is configured."; | | presence "Indicates a down-flag-clear node is configured."; |
| description | | description |
| "Set the up/down bit to 0 in prefix advertisements"; | | "Set the up/down bit to 0 in prefix advertisements"; |
| } | | } |
| } | | } |
| container bgp { | | container bgp { |
| description | | description |
| "Border Gateway Protocol (BGP)"; | | "Border Gateway Protocol (BGP)"; |
| list as { | | list as { |
| key "as-number"; | | key "as-number"; |
| description | | description |
| "bgp as-number"; | | "bgp as-number"; |
| leaf as-number { | | leaf as-number { |
| type xr:Bgp-as-number; | | type xr:Bgp-as-number; |
| description | | description |
| "bgp as-number"; | | "bgp as-number"; |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| } | | } |
| list eigrp { | | list eigrp { |
| key "as-number"; | | key "as-number"; |
| description | | description |
| "EIGRP Protocol"; | | "EIGRP Protocol"; |
| leaf as-number { | | leaf as-number { |
| type uint32 { | | type uint32 { |
| range "1..65535" { | | range "1..65535" { |
| description | | description |
| "Autonomous system number"; | | "Autonomous system number"; |
| } | | } |
| } | | } |
| description | | description |
| "EIGRP Protocol"; | | "EIGRP Protocol"; |
| } | | } |
| container match { | | container match { |
| description | | description |
| "Redistribution of EIGRP routes"; | | "Redistribution of EIGRP routes"; |
| container internal { | | container internal { |
| must "not(../external)"; | | must "not(../external)"; |
| presence "Indicates a internal node is configured."; | | presence "Indicates a internal node is configured."; |
| description | | description |
| "Redistribute EIGRP internal routes"; | | "Redistribute EIGRP internal routes"; |
| } | | } |
| container external { | | container external { |
| must "not(../internal)"; | | must "not(../internal)"; |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "Redistribute EIGRP external routes"; | | "Redistribute EIGRP external routes"; |
| } | | } |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| } | | } |
| leaf maximum-paths { | | leaf maximum-paths { |
| type uint32 { | | type uint32 { |
| range "1..64" { | | range "1..64" { |
| description | | description |
| "Number of paths"; | | "Number of paths"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum number of active parallel paths per route"; | | "Maximum number of active parallel paths per route"; |
| } | | } |
| container router-id { | | container router-id { |
| description | | description |
| "Stable IP address for system"; | | "Stable IP address for system"; |
| leaf interface-name { | | leaf interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Router ID Interface"; | | "Router ID Interface"; |
| } | | } |
| leaf ip-address { | | leaf ip-address { |
| type string; | | type string; |
| description | | description |
| "Router ID address"; | | "Router ID address"; |
| } | | } |
| } | | } |
| container advertise { | | container advertise { |
| description | | description |
| "Control what we advertise in our LSP"; | | "Control what we advertise in our LSP"; |
| container passive-only { | | container passive-only { |
| presence "Indicates a passive-only node is configured."; | | presence "Indicates a passive-only node is configured."; |
| description | | description |
| "Advertise prefixes of passive interfaces only"; | | "Advertise prefixes of passive interfaces only"; |
| } | | } |
| container link { | | container link { |
| description | | description |
| "IS Neighbor attributes"; | | "IS Neighbor attributes"; |
| container attributes { | | container attributes { |
| presence "Indicates a attributes node is configured."; | | presence "Indicates a attributes node is configured."; |
| description | | description |
| "Advertise additional link attributes"; | | "Advertise additional link attributes"; |
| } | | } |
| } | | } |
| container application { | | container application { |
| description | | description |
| "Application Specific Data"; | | "Application Specific Data"; |
| container lfa { | | container lfa { |
| description | | description |
| "LFA Application"; | | "LFA Application"; |
| container link-attributes { | | container link-attributes { |
| description | | description |
| "Application Specific Link Attributes"; | | "Application Specific Link Attributes"; |
| container srlg { | | container srlg { |
| presence "Indicates a srlg node is configured."; | | presence "Indicates a srlg node is configured."; |
| description | | description |
| "Shared Risk Ling Group"; | | "Shared Risk Ling Group"; |
| } | | } |
| } | | } |
| } | | } |
| container flex-algo { | | container flex-algo { |
| description | | description |
| "Flex-Algo Application"; | | "Flex-Algo Application"; |
| container link-attributes { | | container link-attributes { |
| description | | description |
| "Application Specific Link Attributes"; | | "Application Specific Link Attributes"; |
| container srlg { | | container srlg { |
| presence "Indicates a srlg node is configured."; | | presence "Indicates a srlg node is configured."; |
| description | | description |
| "Shared Risk Ling Group"; | | "Shared Risk Ling Group"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container ucmp { | | container ucmp { |
| description | | description |
| "UnEqual Cost Multipath feature"; | | "UnEqual Cost Multipath feature"; |
| container variance { | | container variance { |
| presence "Indicates a variance node is configured."; | | presence "Indicates a variance node is configured."; |
| description | | description |
| "Specify Variance parameter to filter UCMP paths based on cost"; | | "Specify Variance parameter to filter UCMP paths based on cost"; |
| leaf variance-value { | | leaf variance-value { |
| type uint32 { | | type uint32 { |
| range "101..10000" { | | range "101..10000" { |
| description | | description |
| "Variance value"; | | "Variance value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify Variance parameter to filter UCMP paths based on cost"; | | "Specify Variance parameter to filter UCMP paths based on cost"; |
| } | | } |
| leaf prefix-list { | | leaf prefix-list { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Name of the prefix-list"; | | "Name of the prefix-list"; |
| } | | } |
| } | | } |
| description | | description |
| "Specify prefix-list name to filter UCMP paths based on prefixes"; | | "Specify prefix-list name to filter UCMP paths based on prefixes"; |
| } | | } |
| } | | } |
| container exclude { | | container exclude { |
| description | | description |
| "UCMP interface exclusion information"; | | "UCMP interface exclusion information"; |
| container interfaces { | | container interfaces { |
| description | | description |
| "Exclude an interface from UCMP computation"; | | "Exclude an interface from UCMP computation"; |
| list interface { | | list interface { |
| key "interface-name"; | | key "interface-name"; |
| description | | description |
| "Exclude an interface from UCMP computation"; | | "Exclude an interface from UCMP computation"; |
| leaf interface-name { | | leaf interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Exclude an interface from UCMP computation"; | | "Exclude an interface from UCMP computation"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| leaf delay-interval { | | leaf delay-interval { |
| type uint32 { | | type uint32 { |
| range "100..65535" { | | range "100..65535" { |
| description | | description |
| "Delay interval value in milliseconds"; | | "Delay interval value in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "UCMP delay interval"; | | "UCMP delay interval"; |
| } | | } |
| } | | } |
| container microloop { | | container microloop { |
| description | | description |
| "Enable microloop protection feature"; | | "Enable microloop protection feature"; |
| container avoidance { | | container avoidance { |
| n | description | n | presence "Indicates a avoidance node is configured."; |
| "Enable microloop protection type"; | | |
| leaf type { | | |
| type enumeration { | | |
| enum "local" { | | |
| value 1; | | |
| description | | |
| "Local, all prefixes"; | | |
| } | | |
| enum "protected" { | | |
| value 2; | | |
| description | | |
| "Local, for protected prefixes"; | | |
| } | | |
| enum "segment-routing" { | | |
| value 3; | | |
| description | | |
| "Local and remote, Segment Routing"; | | |
| } | | |
| } | | |
| description | | description |
| "Type of microloop avoidance"; | | "Enable local microloop avoidance"; |
| } | | container protected { |
| leaf route-policy { | | must "not(../segment-routing)"; |
| type xr:Route-policy-name; | | presence "Indicates a protected node is configured."; |
| description | | description |
| n | "Distribute prefixes based on a route policy"; | n | "Enable microloop avoidance for only protected prefixes"; |
| | | } |
| | | container segment-routing { |
| | | must "not(../protected)"; |
| | | presence "Indicates a segment-routing node is configured."; |
| | | description |
| | | "Enable segment routing microloop avoidance "; |
| } | | } |
| } | | } |
| leaf avoidance-rib-update-delay { | | leaf avoidance-rib-update-delay { |
| type uint32 { | | type uint32 { |
| range "1000..65535" { | | range "1000..65535" { |
| description | | description |
| "Set value of delay"; | | "Set value of delay"; |
| } | | } |
| } | | } |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| container apply-weight { | | container apply-weight { |
| description | | description |
| "Apply weight"; | | "Apply weight"; |
| container ecmp-only { | | container ecmp-only { |
| must "not(../ucmp-only)"; | | must "not(../ucmp-only)"; |
| presence "Indicates a ecmp-only node is configured."; | | presence "Indicates a ecmp-only node is configured."; |
| description | | description |
| "Apply weights to ecmp paths only"; | | "Apply weights to ecmp paths only"; |
| container bandwidth { | | container bandwidth { |
| presence "Indicates a bandwidth node is configured."; | | presence "Indicates a bandwidth node is configured."; |
| description | | description |
| "Apply weight calculated based on interface bandwidth"; | | "Apply weight calculated based on interface bandwidth"; |
| } | | } |
| } | | } |
| container ucmp-only { | | container ucmp-only { |
| must "not(../ecmp-only)"; | | must "not(../ecmp-only)"; |
| presence "Indicates a ucmp-only node is configured."; | | presence "Indicates a ucmp-only node is configured."; |
| description | | description |
| "Apply weights to ucmp paths only"; | | "Apply weights to ucmp paths only"; |
| } | | } |
| } | | } |
| container summary-prefixes { | | container summary-prefixes { |
| presence "Indicates a summary-prefix node is configured."; | | presence "Indicates a summary-prefix node is configured."; |
| description | | description |
| "Configure IP address prefixes"; | | "Configure IP address prefixes"; |
| list summary-prefix { | | list summary-prefix { |
| key "address-prefix"; | | key "address-prefix"; |
| description | | description |
| "Summary prefix"; | | "Summary prefix"; |
| leaf address-prefix { | | leaf address-prefix { |
| type inet:ip-prefix; | | type inet:ip-prefix; |
| description | | description |
| "Specify prefix associated with this Prefix Segement ID"; | | "Specify prefix associated with this Prefix Segement ID"; |
| } | | } |
| leaf tag { | | leaf tag { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| n | "The tag value used for summary prefix advertisement"; | n | "The tag value"; |
| } | | } |
| } | | } |
| description | | description |
| "Set a tag"; | | "Set a tag"; |
| } | | } |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Summarize routes in one level only"; | | "Summarize routes in one level only"; |
| } | | } |
| leaf algorithm { | | leaf algorithm { |
| when "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'"; | | when "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'"; |
| type uint32 { | | type uint32 { |
| range "128..255"; | | range "128..255"; |
| } | | } |
| description | | description |
| "Flexible Algorithm number"; | | "Flexible Algorithm number"; |
| } | | } |
| container explicit { | | container explicit { |
| when "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'"; | | when "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'"; |
| presence "Indicates a explicit node is configured."; | | presence "Indicates a explicit node is configured."; |
| description | | description |
| "Strict flex-algo locator summarization mode"; | | "Strict flex-algo locator summarization mode"; |
| } | | } |
| n | container adv-unreachable { | n | |
| presence "Indicates a adv-unreachable node is configured."; | | |
| description | | |
| "Advertise unreachable summary component"; | | |
| leaf unreachable-component-tag { | | |
| type uint32 { | | |
| range "1..4294967295" { | | |
| description | | |
| "The tag value of the summary component"; | | |
| } | | |
| } | | |
| description | | |
| "Advertise unreachability only for summary components with a tag"; | | |
| } | | |
| container exclude { | | |
| presence "Indicates explicit mode is configured"; | | |
| description | | |
| "Advertise unreachability only for summary components with a tag"; | | |
| } | | |
| } | | |
| container partition-repair { | | |
| presence "Indicates a partition-repair node is configured."; | | |
| description | | |
| "React to area or domain partition - deaggregate"; | | |
| } | | |
| } | | } |
| } | | } |
| container metric { | | container metric { |
| description | | description |
| "Configure default metric"; | | "Configure default metric"; |
| container default-metric { | | container default-metric { |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| leaf default-metric-value { | | leaf default-metric-value { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set metric at this level only"; | | "Set metric at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| } | | } |
| leaf default-metric-value { | | leaf default-metric-value { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container metric-style { | | container metric-style { |
| description | | description |
| "Use old-style (ISO 10589) or new-style packet formats"; | | "Use old-style (ISO 10589) or new-style packet formats"; |
| container narrow { | | container narrow { |
| must "not(../wide or ../transition)"; | | must "not(../wide or ../transition)"; |
| presence "Indicates a narrow node is configured."; | | presence "Indicates a narrow node is configured."; |
| description | | description |
| "Use old style of TLVs with narrow metric"; | | "Use old style of TLVs with narrow metric"; |
| } | | } |
| container wide { | | container wide { |
| must "not(../narrow or ../transition)"; | | must "not(../narrow or ../transition)"; |
| presence "Indicates a wide node is configured."; | | presence "Indicates a wide node is configured."; |
| description | | description |
| "Use new style of TLVs to carry wider metric"; | | "Use new style of TLVs to carry wider metric"; |
| } | | } |
| container transition { | | container transition { |
| must "not(../narrow or ../wide)"; | | must "not(../narrow or ../wide)"; |
| presence "Indicates a transition node is configured."; | | presence "Indicates a transition node is configured."; |
| description | | description |
| "Send and accept both styles of TLVs during transition"; | | "Send and accept both styles of TLVs during transition"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set metric-style for one level only"; | | "Set metric-style for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric-style for one level only"; | | "Set metric-style for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric-style for one level only"; | | "Set metric-style for one level only"; |
| } | | } |
| container narrow { | | container narrow { |
| must "not(../wide or ../transition)"; | | must "not(../wide or ../transition)"; |
| presence "Indicates a narrow node is configured."; | | presence "Indicates a narrow node is configured."; |
| description | | description |
| "Use old style of TLVs with narrow metric"; | | "Use old style of TLVs with narrow metric"; |
| } | | } |
| container wide { | | container wide { |
| must "not(../narrow or ../transition)"; | | must "not(../narrow or ../transition)"; |
| presence "Indicates a wide node is configured."; | | presence "Indicates a wide node is configured."; |
| description | | description |
| "Use new style of TLVs to carry wider metric"; | | "Use new style of TLVs to carry wider metric"; |
| } | | } |
| container transition { | | container transition { |
| must "not(../narrow or ../wide)"; | | must "not(../narrow or ../wide)"; |
| presence "Indicates a transition node is configured."; | | presence "Indicates a transition node is configured."; |
| description | | description |
| "Send and accept both styles of TLVs during transition"; | | "Send and accept both styles of TLVs during transition"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container spf-interval { | | container spf-interval { |
| description | | description |
| "Route calculation scheduling parameters (FSPF, ISPF, PRC)"; | | "Route calculation scheduling parameters (FSPF, ISPF, PRC)"; |
| n | container ietf { | n | |
| presence "Indicates a ietf node is configured."; | | |
| description | | |
| "Use RFC 8405 backoff algorithm"; | | |
| leaf initial-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Initial delay before running a route calculation"; | | |
| } | | |
| leaf short-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Short delay before running a route calculation"; | | |
| } | | |
| leaf long-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Long delay before running a route calculation"; | | |
| } | | |
| leaf learn-interval-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Time To Learn interval for running a route calculation"; | | |
| } | | |
| leaf holddown-interval-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Holddown interval for running a route calculation"; | | |
| } | | |
| } | | |
| container maximum-wait { | | container maximum-wait { |
| description | | description |
| "Maximum delay before running a route calculation"; | | "Maximum delay before running a route calculation"; |
| leaf maximum-wait-time { | | leaf maximum-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum delay before running a route calculation"; | | "Maximum delay before running a route calculation"; |
| } | | } |
| } | | } |
| container initial-wait { | | container initial-wait { |
| description | | description |
| "Initial delay before running a route calculation"; | | "Initial delay before running a route calculation"; |
| leaf initial-wait-time { | | leaf initial-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Initial delay before running a route calculation"; | | "Initial delay before running a route calculation"; |
| } | | } |
| } | | } |
| container secondary-wait { | | container secondary-wait { |
| description | | description |
| "Secondary delay before running a route calculation"; | | "Secondary delay before running a route calculation"; |
| leaf secondary-wait-time { | | leaf secondary-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Secondary delay before running a route calculation"; | | "Secondary delay before running a route calculation"; |
| } | | } |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set SPF interval for one level only"; | | "Set SPF interval for one level only"; |
| list level { | | list level { |
| n | must "ietf or maximum-wait-time or initial-wait-time or secondary-wait-time"; | n | must "maximum-wait-time or initial-wait-time or secondary-wait-time"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set SPF interval for one level only"; | | "Set SPF interval for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set SPF interval for one level only"; | | "Set SPF interval for one level only"; |
| n | } | n | |
| container ietf { | | |
| presence "Indicates a ietf node is configured."; | | |
| description | | |
| "Use RFC 8405 backoff algorithm"; | | |
| leaf initial-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Initial delay before running a route calculation"; | | |
| } | | |
| leaf short-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Short delay before running a route calculation"; | | |
| } | | |
| leaf long-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Long delay before running a route calculation"; | | |
| } | | |
| leaf learn-interval-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Time To Learn interval for running a route calculation"; | | |
| } | | |
| leaf holddown-interval-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Holddown interval for running a route calculation"; | | |
| } | | |
| } | | } |
| leaf maximum-wait-time { | | leaf maximum-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum delay before running a route calculation"; | | "Maximum delay before running a route calculation"; |
| } | | } |
| leaf initial-wait-time { | | leaf initial-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Initial delay before running a route calculation"; | | "Initial delay before running a route calculation"; |
| } | | } |
| leaf secondary-wait-time { | | leaf secondary-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Secondary delay before running a route calculation"; | | "Secondary delay before running a route calculation"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container spf { | | container spf { |
| description | | description |
| "SPF configuration"; | | "SPF configuration"; |
| container periodic { | | container periodic { |
| description | | description |
| "Configure the periodic SPF"; | | "Configure the periodic SPF"; |
| leaf interval { | | leaf interval { |
| type union { | | type union { |
| type enumeration { | | type enumeration { |
| enum "disable-periodic-spf" { | | enum "disable-periodic-spf" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the periodic SPF (spf periodic disable)"; | | "Disable the periodic SPF (spf periodic disable)"; |
| } | | } |
| } | | } |
| type uint32 { | | type uint32 { |
| range "1..3600" { | | range "1..3600" { |
| description | | description |
| "Maximum interval in between SPF runs in seconds(spf periodic interval <value>)"; | | "Maximum interval in between SPF runs in seconds(spf periodic interval <value>)"; |
| } | | } |
| } | | } |
| } | | } |
| description | | description |
| "Set the maximum interval in between SPF runs"; | | "Set the maximum interval in between SPF runs"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure periodic SPF interval for for one level only"; | | "Configure periodic SPF interval for for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure periodic SPF interval for for one level only"; | | "Configure periodic SPF interval for for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure periodic SPF interval for for one level only"; | | "Configure periodic SPF interval for for one level only"; |
| } | | } |
| leaf interval { | | leaf interval { |
| type union { | | type union { |
| type enumeration { | | type enumeration { |
| enum "disable-periodic-spf" { | | enum "disable-periodic-spf" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the periodic SPF (spf periodic disable)"; | | "Disable the periodic SPF (spf periodic disable)"; |
| } | | } |
| } | | } |
| type uint32 { | | type uint32 { |
| range "1..3600" { | | range "1..3600" { |
| description | | description |
| "Maximum interval in between SPF runs in seconds(spf periodic interval <value>)"; | | "Maximum interval in between SPF runs in seconds(spf periodic interval <value>)"; |
| } | | } |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set the maximum interval in between SPF runs"; | | "Set the maximum interval in between SPF runs"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container prefix-priority { | | container prefix-priority { |
| description | | description |
| "Configure a prefix priority list"; | | "Configure a prefix priority list"; |
| list prefix-priority { | | list prefix-priority { |
| must "tag or access-list-name"; | | must "tag or access-list-name"; |
| key "priority"; | | key "priority"; |
| description | | description |
| "Configure a prefix priority list"; | | "Configure a prefix priority list"; |
| leaf priority { | | leaf priority { |
| type enumeration { | | type enumeration { |
| enum "critical" { | | enum "critical" { |
| value 0; | | value 0; |
| description | | description |
| "Specify critical priority prefixes"; | | "Specify critical priority prefixes"; |
| } | | } |
| enum "high" { | | enum "high" { |
| value 1; | | value 1; |
| description | | description |
| "Specify high priority prefixes"; | | "Specify high priority prefixes"; |
| } | | } |
| enum "medium" { | | enum "medium" { |
| value 2; | | value 2; |
| description | | description |
| "Specify medium priority prefixes"; | | "Specify medium priority prefixes"; |
| } | | } |
| } | | } |
| description | | description |
| "prefix priority"; | | "prefix priority"; |
| } | | } |
| leaf tag { | | leaf tag { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "The tag to indicate priority"; | | "The tag to indicate priority"; |
| } | | } |
| } | | } |
| must "not(../access-list-name)"; | | must "not(../access-list-name)"; |
| description | | description |
| "Specify a tag to indicate priority"; | | "Specify a tag to indicate priority"; |
| } | | } |
| leaf access-list-name { | | leaf access-list-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Access-list name"; | | "Access-list name"; |
| } | | } |
| } | | } |
| must "not(../tag)"; | | must "not(../tag)"; |
| description | | description |
| "Access-list name"; | | "Access-list name"; |
| } | | } |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure SPF prefix priority list for one level only"; | | "Configure SPF prefix priority list for one level only"; |
| list level { | | list level { |
| must "tag or access-list-name"; | | must "tag or access-list-name"; |
| key "level-id priority"; | | key "level-id priority"; |
| description | | description |
| "Configure SPF prefix priority list for one level only"; | | "Configure SPF prefix priority list for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure SPF prefix priority list for one level only"; | | "Configure SPF prefix priority list for one level only"; |
| } | | } |
| leaf priority { | | leaf priority { |
| type enumeration { | | type enumeration { |
| enum "critical" { | | enum "critical" { |
| value 0; | | value 0; |
| description | | description |
| "Specify critical priority prefixes"; | | "Specify critical priority prefixes"; |
| } | | } |
| enum "high" { | | enum "high" { |
| value 1; | | value 1; |
| description | | description |
| "Specify high priority prefixes"; | | "Specify high priority prefixes"; |
| } | | } |
| enum "medium" { | | enum "medium" { |
| value 2; | | value 2; |
| description | | description |
| "Specify medium priority prefixes"; | | "Specify medium priority prefixes"; |
| } | | } |
| } | | } |
| description | | description |
| "prefix priority"; | | "prefix priority"; |
| } | | } |
| leaf tag { | | leaf tag { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "The tag to indicate priority"; | | "The tag to indicate priority"; |
| } | | } |
| } | | } |
| must "not(../access-list-name)"; | | must "not(../access-list-name)"; |
| description | | description |
| "Specify a tag to indicate priority"; | | "Specify a tag to indicate priority"; |
| } | | } |
| leaf access-list-name { | | leaf access-list-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Access-list name"; | | "Access-list name"; |
| } | | } |
| } | | } |
| must "not(../tag)"; | | must "not(../tag)"; |
| description | | description |
| "Access-list name"; | | "Access-list name"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container maximum-redistributed-prefixes { | | container maximum-redistributed-prefixes { |
| description | | description |
| "Maximum number of redistributed prefixes"; | | "Maximum number of redistributed prefixes"; |
| leaf maximum-prefixes { | | leaf maximum-prefixes { |
| type uint32 { | | type uint32 { |
| range "1..28000" { | | range "1..28000" { |
| description | | description |
| "maximum limit on number of redistributed prefixes"; | | "maximum limit on number of redistributed prefixes"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum number of redistributed prefixes"; | | "Maximum number of redistributed prefixes"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set maximum redistributed prefixes for one level only"; | | "Set maximum redistributed prefixes for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set maximum redistributed prefixes for one level only"; | | "Set maximum redistributed prefixes for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set maximum redistributed prefixes for one level only"; | | "Set maximum redistributed prefixes for one level only"; |
| } | | } |
| leaf maximum-prefixes { | | leaf maximum-prefixes { |
| type uint32 { | | type uint32 { |
| range "1..28000" { | | range "1..28000" { |
| description | | description |
| "maximum limit on number of redistributed prefixes"; | | "maximum limit on number of redistributed prefixes"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Maximum number of redistributed prefixes"; | | "Maximum number of redistributed prefixes"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container propagates { | | container propagates { |
| description | | description |
| "Propagate routes between IS-IS levels"; | | "Propagate routes between IS-IS levels"; |
| list propagate { | | list propagate { |
| key "level into-level"; | | key "level into-level"; |
| description | | description |
| "Source level"; | | "Source level"; |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| n | description | n | |
| "level"; | | |
| } | | } |
| leaf into-level { | | leaf into-level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Destination level"; | | "Destination level"; |
| } | | } |
| } | | } |
| description | | description |
| "into"; | | "into"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| mandatory true; | | mandatory true; |
| description | | description |
| "Propagate only specified routes"; | | "Propagate only specified routes"; |
| } | | } |
| } | | } |
| } | | } |
| container adjacency-check { | | container adjacency-check { |
| description | | description |
| "Suppress checking of consistent AF support on received IIHs"; | | "Suppress checking of consistent AF support on received IIHs"; |
| container disable { | | container disable { |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable adjacency-checking"; | | "Disable adjacency-checking"; |
| } | | } |
| } | | } |
| container route { | | container route { |
| description | | description |
| "Control the advertisement of routes in the RIB"; | | "Control the advertisement of routes in the RIB"; |
| container source { | | container source { |
| description | | description |
| "Control the path source value"; | | "Control the path source value"; |
| container first-hop { | | container first-hop { |
| presence "Indicates a first-hop node is configured."; | | presence "Indicates a first-hop node is configured."; |
| description | | description |
| "Use the IP address of the first-hop"; | | "Use the IP address of the first-hop"; |
| } | | } |
| } | | } |
| } | | } |
| container attached-bit { | | container attached-bit { |
| description | | description |
| "Modify behavior of the attached-bit"; | | "Modify behavior of the attached-bit"; |
| container send { | | container send { |
| description | | description |
| "Modify how we set the attached bit"; | | "Modify how we set the attached bit"; |
| container always-set { | | container always-set { |
| must "not(../never-set)"; | | must "not(../never-set)"; |
| presence "Indicates a always-set node is configured."; | | presence "Indicates a always-set node is configured."; |
| description | | description |
| "Always set the attached bit in our LSP"; | | "Always set the attached bit in our LSP"; |
| } | | } |
| container never-set { | | container never-set { |
| must "not(../always-set)"; | | must "not(../always-set)"; |
| presence "Indicates a never-set node is configured."; | | presence "Indicates a never-set node is configured."; |
| description | | description |
| "Never set the attached bit our LSP"; | | "Never set the attached bit our LSP"; |
| } | | } |
| } | | } |
| container receive { | | container receive { |
| description | | description |
| "Modify how we treat received attached bits"; | | "Modify how we treat received attached bits"; |
| container ignore { | | container ignore { |
| presence "Indicates a ignore node is configured."; | | presence "Indicates a ignore node is configured."; |
| description | | description |
| "Ignore the attached bit in received LSPs"; | | "Ignore the attached bit in received LSPs"; |
| } | | } |
| } | | } |
| } | | } |
| container fast-reroute { | | container fast-reroute { |
| description | | description |
| "Configure Fast ReRoute"; | | "Configure Fast ReRoute"; |
| leaf delay-interval { | | leaf delay-interval { |
| type uint32 { | | type uint32 { |
| range "100..60000" { | | range "100..60000" { |
| description | | description |
| "Delay before running FRR (milliseconds)"; | | "Delay before running FRR (milliseconds)"; |
| } | | } |
| } | | } |
| description | | description |
| "Delay before running FRR computation"; | | "Delay before running FRR computation"; |
| } | | } |
| container per-link { | | container per-link { |
| when "../../saf-name = 'unicast'"; | | when "../../saf-name = 'unicast'"; |
| description | | description |
| "Prefix independent per-link computation"; | | "Prefix independent per-link computation"; |
| container priority-limit { | | container priority-limit { |
| description | | description |
| "Limit backup computation upto the prefix priority"; | | "Limit backup computation upto the prefix priority"; |
| container critical { | | container critical { |
| must "not(../high or ../medium)"; | | must "not(../high or ../medium)"; |
| presence "Indicates a critical node is configured."; | | presence "Indicates a critical node is configured."; |
| description | | description |
| "Compute for critical priority prefixes only"; | | "Compute for critical priority prefixes only"; |
| } | | } |
| container high { | | container high { |
| must "not(../critical or ../medium)"; | | must "not(../critical or ../medium)"; |
| presence "Indicates a high node is configured."; | | presence "Indicates a high node is configured."; |
| description | | description |
| "Compute for critical & high priority prefixes"; | | "Compute for critical & high priority prefixes"; |
| } | | } |
| container medium { | | container medium { |
| must "not(../critical or ../high)"; | | must "not(../critical or ../high)"; |
| presence "Indicates a medium node is configured."; | | presence "Indicates a medium node is configured."; |
| description | | description |
| "Compute for critical, high & medium priority prefixes"; | | "Compute for critical, high & medium priority prefixes"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set priority-limit for one level only"; | | "Set priority-limit for one level only"; |
| list level { | | list level { |
| must "critical or high or medium"; | | must "critical or high or medium"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set priority-limit for one level only"; | | "Set priority-limit for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set priority-limit for one level only"; | | "Set priority-limit for one level only"; |
| } | | } |
| container critical { | | container critical { |
| must "not(../high or ../medium)"; | | must "not(../high or ../medium)"; |
| presence "Indicates a critical node is configured."; | | presence "Indicates a critical node is configured."; |
| description | | description |
| "Compute for critical priority prefixes only"; | | "Compute for critical priority prefixes only"; |
| } | | } |
| container high { | | container high { |
| must "not(../critical or ../medium)"; | | must "not(../critical or ../medium)"; |
| presence "Indicates a high node is configured."; | | presence "Indicates a high node is configured."; |
| description | | description |
| "Compute for critical & high priority prefixes"; | | "Compute for critical & high priority prefixes"; |
| } | | } |
| container medium { | | container medium { |
| must "not(../critical or ../high)"; | | must "not(../critical or ../high)"; |
| presence "Indicates a medium node is configured."; | | presence "Indicates a medium node is configured."; |
| description | | description |
| "Compute for critical, high & medium priority prefixes"; | | "Compute for critical, high & medium priority prefixes"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container use-candidate-only { | | container use-candidate-only { |
| description | | description |
| "Exclude all interfaces from computation"; | | "Exclude all interfaces from computation"; |
| container candidate-only { | | container candidate-only { |
| presence "Indicates a use-candidate-only node is configured."; | | presence "Indicates a use-candidate-only node is configured."; |
| description | | description |
| "Exclude all interfaces from computation"; | | "Exclude all interfaces from computation"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Exclude all interfaces for one level only"; | | "Exclude all interfaces for one level only"; |
| list level { | | list level { |
| must "candidate-only"; | | must "candidate-only"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Exclude all interfaces for one level only"; | | "Exclude all interfaces for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Exclude all interfaces for one level only"; | | "Exclude all interfaces for one level only"; |
| } | | } |
| container candidate-only { | | container candidate-only { |
| presence "Indicates a use-candidate-only node is configured."; | | presence "Indicates a use-candidate-only node is configured."; |
| description | | description |
| "Exclude all interfaces from computation"; | | "Exclude all interfaces from computation"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container per-prefix { | | container per-prefix { |
| when "../../saf-name = 'unicast'"; | | when "../../saf-name = 'unicast'"; |
| description | | description |
| "Prefix dependent computation"; | | "Prefix dependent computation"; |
| container priority-limit { | | container priority-limit { |
| description | | description |
| "Limit backup computation upto the prefix priority"; | | "Limit backup computation upto the prefix priority"; |
| container critical { | | container critical { |
| must "not(../high or ../medium)"; | | must "not(../high or ../medium)"; |
| presence "Indicates a critical node is configured."; | | presence "Indicates a critical node is configured."; |
| description | | description |
| "Compute for critical priority prefixes only"; | | "Compute for critical priority prefixes only"; |
| } | | } |
| container high { | | container high { |
| must "not(../critical or ../medium)"; | | must "not(../critical or ../medium)"; |
| presence "Indicates a high node is configured."; | | presence "Indicates a high node is configured."; |
| description | | description |
| "Compute for critical & high priority prefixes"; | | "Compute for critical & high priority prefixes"; |
| } | | } |
| container medium { | | container medium { |
| must "not(../critical or ../high)"; | | must "not(../critical or ../high)"; |
| presence "Indicates a medium node is configured."; | | presence "Indicates a medium node is configured."; |
| description | | description |
| "Compute for critical, high & medium priority prefixes"; | | "Compute for critical, high & medium priority prefixes"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set priority-limit for one level only"; | | "Set priority-limit for one level only"; |
| list level { | | list level { |
| must "critical or high or medium"; | | must "critical or high or medium"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set priority-limit for one level only"; | | "Set priority-limit for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set priority-limit for one level only"; | | "Set priority-limit for one level only"; |
| } | | } |
| container critical { | | container critical { |
| must "not(../high or ../medium)"; | | must "not(../high or ../medium)"; |
| presence "Indicates a critical node is configured."; | | presence "Indicates a critical node is configured."; |
| description | | description |
| "Compute for critical priority prefixes only"; | | "Compute for critical priority prefixes only"; |
| } | | } |
| container high { | | container high { |
| must "not(../critical or ../medium)"; | | must "not(../critical or ../medium)"; |
| presence "Indicates a high node is configured."; | | presence "Indicates a high node is configured."; |
| description | | description |
| "Compute for critical & high priority prefixes"; | | "Compute for critical & high priority prefixes"; |
| } | | } |
| container medium { | | container medium { |
| must "not(../critical or ../high)"; | | must "not(../critical or ../high)"; |
| presence "Indicates a medium node is configured."; | | presence "Indicates a medium node is configured."; |
| description | | description |
| "Compute for critical, high & medium priority prefixes"; | | "Compute for critical, high & medium priority prefixes"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container use-candidate-only { | | container use-candidate-only { |
| description | | description |
| "Exclude all interfaces from computation"; | | "Exclude all interfaces from computation"; |
| container candidate-only { | | container candidate-only { |
| presence "Indicates a use-candidate-only node is configured."; | | presence "Indicates a use-candidate-only node is configured."; |
| description | | description |
| "Exclude all interfaces from computation"; | | "Exclude all interfaces from computation"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Exclude all interfaces for one level only"; | | "Exclude all interfaces for one level only"; |
| list level { | | list level { |
| must "candidate-only"; | | must "candidate-only"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Exclude all interfaces for one level only"; | | "Exclude all interfaces for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Exclude all interfaces for one level only"; | | "Exclude all interfaces for one level only"; |
| } | | } |
| container candidate-only { | | container candidate-only { |
| presence "Indicates a use-candidate-only node is configured."; | | presence "Indicates a use-candidate-only node is configured."; |
| description | | description |
| "Exclude all interfaces from computation"; | | "Exclude all interfaces from computation"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container tiebreaker { | | container tiebreaker { |
| description | | description |
| "Configure tiebreaker for multiple backups"; | | "Configure tiebreaker for multiple backups"; |
| container downstream { | | container downstream { |
| description | | description |
| "Prefer backup path via downstream node"; | | "Prefer backup path via downstream node"; |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| } | | } |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container lc-disjoint { | | container lc-disjoint { |
| description | | description |
| "Prefer line card disjoint backup path"; | | "Prefer line card disjoint backup path"; |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| } | | } |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container lowest-backup-metric { | | container lowest-backup-metric { |
| description | | description |
| "Prefer backup path with lowest total metric"; | | "Prefer backup path with lowest total metric"; |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| } | | } |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container node-protecting { | | container node-protecting { |
| description | | description |
| "Prefer node protecting backup path"; | | "Prefer node protecting backup path"; |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| } | | } |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container primary-path { | | container primary-path { |
| description | | description |
| "Prefer backup path from ECMP set"; | | "Prefer backup path from ECMP set"; |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| } | | } |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container secondary-path { | | container secondary-path { |
| description | | description |
| "Prefer non-ECMP backup path"; | | "Prefer non-ECMP backup path"; |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| } | | } |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container srlg-disjoint { | | container srlg-disjoint { |
| description | | description |
| "Prefer SRLG disjoint backup path"; | | "Prefer SRLG disjoint backup path"; |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| } | | } |
| leaf index { | | leaf index { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container load-sharing { | | container load-sharing { |
| description | | description |
| "Load share prefixes across multiple backups"; | | "Load share prefixes across multiple backups"; |
| container disable { | | container disable { |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable load sharing"; | | "Disable load sharing"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Disable load sharing for one level only"; | | "Disable load sharing for one level only"; |
| list level { | | list level { |
| must "disable"; | | must "disable"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Disable load sharing for one level only"; | | "Disable load sharing for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Disable load sharing for one level only"; | | "Disable load sharing for one level only"; |
| } | | } |
| container disable { | | container disable { |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable load sharing"; | | "Disable load sharing"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container remote-lfa { | | container remote-lfa { |
| description | | description |
| "Enable remote LFA related configuration"; | | "Enable remote LFA related configuration"; |
| container prefix-list { | | container prefix-list { |
| description | | description |
| "Filter PQ node router ID based on prefix list"; | | "Filter PQ node router ID based on prefix list"; |
| leaf prefix-list-name { | | leaf prefix-list-name { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Prefix-list name"; | | "Prefix-list name"; |
| } | | } |
| } | | } |
| description | | description |
| "Filter PQ node router ID based on prefix list"; | | "Filter PQ node router ID based on prefix list"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Enable router ID filtering for one level only"; | | "Enable router ID filtering for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Enable router ID filtering for one level only"; | | "Enable router ID filtering for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Enable router ID filtering for one level only"; | | "Enable router ID filtering for one level only"; |
| } | | } |
| leaf prefix-list-name { | | leaf prefix-list-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Prefix-list name"; | | "Prefix-list name"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Filter PQ node router ID based on prefix list"; | | "Filter PQ node router ID based on prefix list"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container srlg-protection { | | container srlg-protection { |
| description | | description |
| "Type of SRLG protection"; | | "Type of SRLG protection"; |
| container weighted-global { | | container weighted-global { |
| presence "Indicates a weighted-global node is configured."; | | presence "Indicates a weighted-global node is configured."; |
| description | | description |
| "Weighted global SRLG protection"; | | "Weighted global SRLG protection"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set SRLG protection type for one level only"; | | "Set SRLG protection type for one level only"; |
| list level { | | list level { |
| must "weighted-global"; | | must "weighted-global"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set SRLG protection type for one level only"; | | "Set SRLG protection type for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set SRLG protection type for one level only"; | | "Set SRLG protection type for one level only"; |
| } | | } |
| container weighted-global { | | container weighted-global { |
| presence "Indicates a weighted-global node is configured."; | | presence "Indicates a weighted-global node is configured."; |
| description | | description |
| "Weighted global SRLG protection"; | | "Weighted global SRLG protection"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container monitor-convergence { | | container monitor-convergence { |
| presence "Indicates a monitor-convergence node is configured."; | | presence "Indicates a monitor-convergence node is configured."; |
| description | | description |
| "Enables convergence monitoring"; | | "Enables convergence monitoring"; |
| leaf prefix-list { | | leaf prefix-list { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Prefix List Name"; | | "Prefix List Name"; |
| } | | } |
| } | | } |
| description | | description |
| "Enables Individual Prefix Monitoring"; | | "Enables Individual Prefix Monitoring"; |
| } | | } |
| container track-ip-frr { | | container track-ip-frr { |
| presence "Indicates a track-ip-frr node is configured."; | | presence "Indicates a track-ip-frr node is configured."; |
| description | | description |
| "Enables Tracking IP-Frr Convergence"; | | "Enables Tracking IP-Frr Convergence"; |
| } | | } |
| } | | } |
| container mpls { | | container mpls { |
| description | | description |
| "Configure MPLS routing protocol parameters"; | | "Configure MPLS routing protocol parameters"; |
| container ldp { | | container ldp { |
| description | | description |
| "Configure LDP parameters"; | | "Configure LDP parameters"; |
| container auto-config { | | container auto-config { |
| presence "Indicates a auto-config node is configured."; | | presence "Indicates a auto-config node is configured."; |
| description | | description |
| "Enable LDP IGP interface auto-configuration"; | | "Enable LDP IGP interface auto-configuration"; |
| } | | } |
| } | | } |
| container traffic-eng { | | container traffic-eng { |
| description | | description |
| "Routing protocol commands for MPLS Traffic Engineering"; | | "Routing protocol commands for MPLS Traffic Engineering"; |
| container router-id { | | container router-id { |
| description | | description |
| "Traffic Engineering stable IP address for system"; | | "Traffic Engineering stable IP address for system"; |
| leaf ip-address { | | leaf ip-address { |
| type inet:ipv4-address-no-zone; | | type inet:ipv4-address-no-zone; |
| description | | description |
| "configure this node"; | | "configure this node"; |
| } | | } |
| leaf interface { | | leaf interface { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| ""; | | ""; |
| } | | } |
| } | | } |
| container igp-intact { | | container igp-intact { |
| presence "Indicates a igp-intact node is configured."; | | presence "Indicates a igp-intact node is configured."; |
| description | | description |
| "Install both TE and non-TE nexthops in the RIB."; | | "Install both TE and non-TE nexthops in the RIB."; |
| } | | } |
| container multicast-intact { | | container multicast-intact { |
| presence "Indicates a multicast-intact node is configured."; | | presence "Indicates a multicast-intact node is configured."; |
| description | | description |
| "Install non-TE nexthops in the RIB for use by multicast"; | | "Install non-TE nexthops in the RIB for use by multicast"; |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Enable mpls traffic-eng at both level 1 and 2"; | | "Enable mpls traffic-eng at both level 1 and 2"; |
| } | | } |
| container level-1 { | | container level-1 { |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Enable mpls traffic-eng at level 1"; | | "Enable mpls traffic-eng at level 1"; |
| } | | } |
| container level-2-only { | | container level-2-only { |
| presence "Indicates a level-2-only node is configured."; | | presence "Indicates a level-2-only node is configured."; |
| description | | description |
| "Enable mpls traffic-eng at level 2"; | | "Enable mpls traffic-eng at level 2"; |
| } | | } |
| container tunnel { | | container tunnel { |
| description | | description |
| "Tunnel selection"; | | "Tunnel selection"; |
| container restricted { | | container restricted { |
| presence "Indicates a restricted node is configured."; | | presence "Indicates a restricted node is configured."; |
| description | | description |
| "Use only primary tunnel for destination IP address"; | | "Use only primary tunnel for destination IP address"; |
| } | | } |
| container preferred { | | container preferred { |
| presence "Indicates a preferred node is configured."; | | presence "Indicates a preferred node is configured."; |
| description | | description |
| "Prefer TE tunnels over equal-cost physical paths"; | | "Prefer TE tunnels over equal-cost physical paths"; |
| } | | } |
| n | container anycast-prefer-igp-cost { | n | |
| presence "Indicates a anycast-prefer-igp-cost node is configured."; | | |
| description | | |
| "Prefer anycast prefix with lowest IGP cost"; | | |
| } | | |
| container metric { | | container metric { |
| description | | description |
| "Default metric for forwarding-adjacency tunnels"; | | "Default metric for forwarding-adjacency tunnels"; |
| leaf default-metric { | | leaf default-metric { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Default metric for forwarding-adjacency tunnels"; | | "Default metric for forwarding-adjacency tunnels"; |
| } | | } |
| } | | } |
| description | | description |
| "Default metric for forwarding-adjacency tunnels"; | | "Default metric for forwarding-adjacency tunnels"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set metric at this level only"; | | "Set metric at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| } | | } |
| leaf default-metric { | | leaf default-metric { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Default metric for forwarding-adjacency tunnels"; | | "Default metric for forwarding-adjacency tunnels"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Default metric for forwarding-adjacency tunnels"; | | "Default metric for forwarding-adjacency tunnels"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container single-topology { | | container single-topology { |
| when "../af-name = 'ipv6' and ../saf-name = 'unicast'"; | | when "../af-name = 'ipv6' and ../saf-name = 'unicast'"; |
| presence "Indicates a single-topology node is configured."; | | presence "Indicates a single-topology node is configured."; |
| description | | description |
| "Run IPv6 Unicast using the standard (IPv4 Unicast) topology"; | | "Run IPv6 Unicast using the standard (IPv4 Unicast) topology"; |
| } | | } |
| } | | } |
| list address-family-topology { | | list address-family-topology { |
| key "af-name saf-name topology-name"; | | key "af-name saf-name topology-name"; |
| description | | description |
| "IS-IS address family with a non-default topology"; | | "IS-IS address family with a non-default topology"; |
| leaf af-name { | | leaf af-name { |
| type Isis-af-name; | | type Isis-af-name; |
| description | | description |
| "Address family name"; | | "Address family name"; |
| } | | } |
| leaf saf-name { | | leaf saf-name { |
| type Isis-saf-multicast; | | type Isis-saf-multicast; |
| description | | description |
| "Sub address family name"; | | "Sub address family name"; |
| } | | } |
| leaf topology-name { | | leaf topology-name { |
| type string { | | type string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Topology name"; | | "Topology name"; |
| } | | } |
| } | | } |
| description | | description |
| "Specify a non-default topology"; | | "Specify a non-default topology"; |
| } | | } |
| container default-information { | | container default-information { |
| description | | description |
| "Control distribution of default information"; | | "Control distribution of default information"; |
| container originate { | | container originate { |
| presence "Indicates a originate node is configured."; | | presence "Indicates a originate node is configured."; |
| description | | description |
| "Distribute a default route"; | | "Distribute a default route"; |
| container external { | | container external { |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "Originate default prefix as an external route"; | | "Originate default prefix as an external route"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| } | | } |
| } | | } |
| container segment-routing { | | container segment-routing { |
| description | | description |
| "Enable Segment Routing"; | | "Enable Segment Routing"; |
| container mpls { | | container mpls { |
| description | | description |
| "Enable Segment Routing using MPLS encapsulation"; | | "Enable Segment Routing using MPLS encapsulation"; |
| container connected-prefix-sid-map { | | container connected-prefix-sid-map { |
| presence "Indicates a connected-prefix-sid-map node is configured."; | | presence "Indicates a connected-prefix-sid-map node is configured."; |
| description | | description |
| "Enter connected prefix sid map submode"; | | "Enter connected prefix sid map submode"; |
| } | | } |
| } | | } |
| } | | } |
| container distance { | | container distance { |
| description | | description |
| "Configure IS-IS administrative distances"; | | "Configure IS-IS administrative distances"; |
| leaf global-administrative-distance { | | leaf global-administrative-distance { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Administrative distance"; | | "Administrative distance"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure IS-IS administrative distances"; | | "Configure IS-IS administrative distances"; |
| } | | } |
| container route-sources { | | container route-sources { |
| description | | description |
| "Route source for this distance"; | | "Route source for this distance"; |
| list route-source { | | list route-source { |
| key "address-prefix"; | | key "address-prefix"; |
| description | | description |
| "Route source for this distance"; | | "Route source for this distance"; |
| leaf address-prefix { | | leaf address-prefix { |
| type inet:ip-prefix; | | type inet:ip-prefix; |
| description | | description |
| "Route source for this distance"; | | "Route source for this distance"; |
| } | | } |
| leaf administrative-distance { | | leaf administrative-distance { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Administrative distance"; | | "Administrative distance"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure IS-IS administrative distances"; | | "Configure IS-IS administrative distances"; |
| } | | } |
| leaf prefix-access-list { | | leaf prefix-access-list { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Prefix-list or access-list to filter routes for this distance"; | | "Prefix-list or access-list to filter routes for this distance"; |
| } | | } |
| } | | } |
| description | | description |
| "Prefix-list or access-list to filter routes for this distance"; | | "Prefix-list or access-list to filter routes for this distance"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container distribute-list { | | container distribute-list { |
| description | | description |
| "Filter routes sent to the RIB"; | | "Filter routes sent to the RIB"; |
| leaf prefix-list { | | leaf prefix-list { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Prefix-list name"; | | "Prefix-list name"; |
| } | | } |
| } | | } |
| description | | description |
| "Filter routes based on a prefix list"; | | "Filter routes based on a prefix list"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Filter routes based on a route policy"; | | "Filter routes based on a route policy"; |
| } | | } |
| } | | } |
| container redistribute { | | container redistribute { |
| description | | description |
| "Redistribute information from another routing protocol"; | | "Redistribute information from another routing protocol"; |
| container connected { | | container connected { |
| presence "Indicates a connected node is configured."; | | presence "Indicates a connected node is configured."; |
| description | | description |
| "Connected routes"; | | "Connected routes"; |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-1) and not(../level-2)"; | | must "not(../level-1) and not(../level-2)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| list ospf { | | list ospf { |
| when "../../af-name = 'ipv4'"; | | when "../../af-name = 'ipv4'"; |
| key "process-id"; | | key "process-id"; |
| description | | description |
| "Open Shortest Path First (OSPF)"; | | "Open Shortest Path First (OSPF)"; |
| leaf process-id { | | leaf process-id { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "OSPF process ID"; | | "OSPF process ID"; |
| } | | } |
| } | | } |
| description | | description |
| "Open Shortest Path First (OSPF)"; | | "Open Shortest Path First (OSPF)"; |
| } | | } |
| container match { | | container match { |
| description | | description |
| "Redistribution of OSPF routes"; | | "Redistribution of OSPF routes"; |
| container internal { | | container internal { |
| must "not(../external or ../nssa-external)"; | | must "not(../external or ../nssa-external)"; |
| presence "Indicates a internal node is configured."; | | presence "Indicates a internal node is configured."; |
| description | | description |
| "Redistribute OSPF internal routes"; | | "Redistribute OSPF internal routes"; |
| } | | } |
| container external { | | container external { |
| must "not(../internal or ../nssa-external)"; | | must "not(../internal or ../nssa-external)"; |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "Redistribute OSPF external routes"; | | "Redistribute OSPF external routes"; |
| } | | } |
| container nssa-external { | | container nssa-external { |
| must "not(../internal or ../external)"; | | must "not(../internal or ../external)"; |
| presence "Indicates a nssa-external node is configured."; | | presence "Indicates a nssa-external node is configured."; |
| description | | description |
| "Redistribute OSPF NSSA external routes"; | | "Redistribute OSPF NSSA external routes"; |
| } | | } |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-1) and not(../level-2)"; | | must "not(../level-1) and not(../level-2)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| list ospfv3 { | | list ospfv3 { |
| when "../../af-name = 'ipv6'"; | | when "../../af-name = 'ipv6'"; |
| key "process-id"; | | key "process-id"; |
| description | | description |
| "Open Shortest Path First (OSPFv3)"; | | "Open Shortest Path First (OSPFv3)"; |
| leaf process-id { | | leaf process-id { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "OSPF process ID"; | | "OSPF process ID"; |
| } | | } |
| } | | } |
| description | | description |
| "Open Shortest Path First (OSPFv3)"; | | "Open Shortest Path First (OSPFv3)"; |
| } | | } |
| container match { | | container match { |
| description | | description |
| "Redistribution of OSPF routes"; | | "Redistribution of OSPF routes"; |
| container internal { | | container internal { |
| must "not(../external or ../nssa-external)"; | | must "not(../external or ../nssa-external)"; |
| presence "Indicates a internal node is configured."; | | presence "Indicates a internal node is configured."; |
| description | | description |
| "Redistribute OSPF internal routes"; | | "Redistribute OSPF internal routes"; |
| } | | } |
| container external { | | container external { |
| must "not(../internal or ../nssa-external)"; | | must "not(../internal or ../nssa-external)"; |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "Redistribute OSPF external routes"; | | "Redistribute OSPF external routes"; |
| } | | } |
| container nssa-external { | | container nssa-external { |
| must "not(../internal or ../external)"; | | must "not(../internal or ../external)"; |
| presence "Indicates a nssa-external node is configured."; | | presence "Indicates a nssa-external node is configured."; |
| description | | description |
| "Redistribute OSPF NSSA external routes"; | | "Redistribute OSPF NSSA external routes"; |
| } | | } |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-1) and not(../level-2)"; | | must "not(../level-1) and not(../level-2)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| container static { | | container static { |
| presence "Indicates a static node is configured."; | | presence "Indicates a static node is configured."; |
| description | | description |
| "Static routes"; | | "Static routes"; |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| container subscriber { | | container subscriber { |
| presence "Indicates a subscriber node is configured."; | | presence "Indicates a subscriber node is configured."; |
| description | | description |
| "Subscriber routes"; | | "Subscriber routes"; |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| container rip { | | container rip { |
| presence "Indicates a rip node is configured."; | | presence "Indicates a rip node is configured."; |
| description | | description |
| "RIP routes"; | | "RIP routes"; |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| container mobile { | | container mobile { |
| presence "Indicates a mobile node is configured."; | | presence "Indicates a mobile node is configured."; |
| description | | description |
| "Mobile routes"; | | "Mobile routes"; |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| container applications { | | container applications { |
| description | | description |
| "Application routes"; | | "Application routes"; |
| list application { | | list application { |
| key "application-name"; | | key "application-name"; |
| description | | description |
| "Application routes"; | | "Application routes"; |
| leaf application-name { | | leaf application-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "OnePK application name"; | | "OnePK application name"; |
| } | | } |
| } | | } |
| description | | description |
| "Application routes"; | | "Application routes"; |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| } | | } |
| list isis { | | list isis { |
| key "instance-id"; | | key "instance-id"; |
| description | | description |
| "IS-IS"; | | "IS-IS"; |
| leaf instance-id { | | leaf instance-id { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "IS-IS instance identifier"; | | "IS-IS instance identifier"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS"; | | "IS-IS"; |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| container down-flag-clear { | | container down-flag-clear { |
| presence "Indicates a down-flag-clear node is configured."; | | presence "Indicates a down-flag-clear node is configured."; |
| description | | description |
| "Set the up/down bit to 0 in prefix advertisements"; | | "Set the up/down bit to 0 in prefix advertisements"; |
| } | | } |
| } | | } |
| container bgp { | | container bgp { |
| description | | description |
| "Border Gateway Protocol (BGP)"; | | "Border Gateway Protocol (BGP)"; |
| list as { | | list as { |
| key "as-number"; | | key "as-number"; |
| description | | description |
| "bgp as-number"; | | "bgp as-number"; |
| leaf as-number { | | leaf as-number { |
| type xr:Bgp-as-number; | | type xr:Bgp-as-number; |
| description | | description |
| "bgp as-number"; | | "bgp as-number"; |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| } | | } |
| list eigrp { | | list eigrp { |
| key "as-number"; | | key "as-number"; |
| description | | description |
| "EIGRP Protocol"; | | "EIGRP Protocol"; |
| leaf as-number { | | leaf as-number { |
| type uint32 { | | type uint32 { |
| range "1..65535" { | | range "1..65535" { |
| description | | description |
| "Autonomous system number"; | | "Autonomous system number"; |
| } | | } |
| } | | } |
| description | | description |
| "EIGRP Protocol"; | | "EIGRP Protocol"; |
| } | | } |
| container match { | | container match { |
| description | | description |
| "Redistribution of EIGRP routes"; | | "Redistribution of EIGRP routes"; |
| container internal { | | container internal { |
| must "not(../external)"; | | must "not(../external)"; |
| presence "Indicates a internal node is configured."; | | presence "Indicates a internal node is configured."; |
| description | | description |
| "Redistribute EIGRP internal routes"; | | "Redistribute EIGRP internal routes"; |
| } | | } |
| container external { | | container external { |
| must "not(../internal)"; | | must "not(../internal)"; |
| presence "Indicates a external node is configured."; | | presence "Indicates a external node is configured."; |
| description | | description |
| "Redistribute EIGRP external routes"; | | "Redistribute EIGRP external routes"; |
| } | | } |
| } | | } |
| container level-1-2 { | | container level-1-2 { |
| must "not(../level-2) and not(../level-1)"; | | must "not(../level-2) and not(../level-1)"; |
| presence "Indicates a level-1-2 node is configured."; | | presence "Indicates a level-1-2 node is configured."; |
| description | | description |
| "Redistribute routes into both levels"; | | "Redistribute routes into both levels"; |
| } | | } |
| container level-2 { | | container level-2 { |
| must "not(../level-1-2) and not(../level-1)"; | | must "not(../level-1-2) and not(../level-1)"; |
| presence "Indicates a level-2 node is configured."; | | presence "Indicates a level-2 node is configured."; |
| description | | description |
| "Redistribute routes into level 2 only (the default)"; | | "Redistribute routes into level 2 only (the default)"; |
| } | | } |
| container level-1 { | | container level-1 { |
| must "not(../level-1-2) and not(../level-2)"; | | must "not(../level-1-2) and not(../level-2)"; |
| presence "Indicates a level-1 node is configured."; | | presence "Indicates a level-1 node is configured."; |
| description | | description |
| "Redistribute routes into level 1 only"; | | "Redistribute routes into level 1 only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Default metric: <0-63> for narrow, <0-16777215> for wide"; | | "Default metric: <0-63> for narrow, <0-16777215> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Metric for redistributed routes"; | | "Metric for redistributed routes"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Route policy reference"; | | "Route policy reference"; |
| } | | } |
| leaf metric-type { | | leaf metric-type { |
| type enumeration { | | type enumeration { |
| enum "internal" { | | enum "internal" { |
| value 0; | | value 0; |
| description | | description |
| "Set IS-IS Internal metric type"; | | "Set IS-IS Internal metric type"; |
| } | | } |
| enum "external" { | | enum "external" { |
| value 1; | | value 1; |
| description | | description |
| "Set IS-IS External metric type"; | | "Set IS-IS External metric type"; |
| } | | } |
| enum "rib-metric-as-internal" { | | enum "rib-metric-as-internal" { |
| value 2; | | value 2; |
| description | | description |
| "Set IS-IS Internal metric type and use RIB metric"; | | "Set IS-IS Internal metric type and use RIB metric"; |
| } | | } |
| enum "rib-metric-as-external" { | | enum "rib-metric-as-external" { |
| value 3; | | value 3; |
| description | | description |
| "Set IS-IS External metric type and use RIB metric"; | | "Set IS-IS External metric type and use RIB metric"; |
| } | | } |
| } | | } |
| description | | description |
| "IS-IS metric type for redistributed routes"; | | "IS-IS metric type for redistributed routes"; |
| } | | } |
| } | | } |
| } | | } |
| leaf maximum-paths { | | leaf maximum-paths { |
| type uint32 { | | type uint32 { |
| range "1..64" { | | range "1..64" { |
| description | | description |
| "Number of paths"; | | "Number of paths"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum number of active parallel paths per route"; | | "Maximum number of active parallel paths per route"; |
| } | | } |
| container advertise { | | container advertise { |
| description | | description |
| "Control what we advertise in our LSP"; | | "Control what we advertise in our LSP"; |
| container passive-only { | | container passive-only { |
| presence "Indicates a passive-only node is configured."; | | presence "Indicates a passive-only node is configured."; |
| description | | description |
| "Advertise prefixes of passive interfaces only"; | | "Advertise prefixes of passive interfaces only"; |
| } | | } |
| container link { | | container link { |
| description | | description |
| "IS Neighbor attributes"; | | "IS Neighbor attributes"; |
| container attributes { | | container attributes { |
| presence "Indicates a attributes node is configured."; | | presence "Indicates a attributes node is configured."; |
| description | | description |
| "Advertise additional link attributes"; | | "Advertise additional link attributes"; |
| } | | } |
| } | | } |
| container application { | | container application { |
| description | | description |
| "Application Specific Data"; | | "Application Specific Data"; |
| container lfa { | | container lfa { |
| description | | description |
| "LFA Application"; | | "LFA Application"; |
| container link-attributes { | | container link-attributes { |
| description | | description |
| "Application Specific Link Attributes"; | | "Application Specific Link Attributes"; |
| container srlg { | | container srlg { |
| presence "Indicates a srlg node is configured."; | | presence "Indicates a srlg node is configured."; |
| description | | description |
| "Shared Risk Ling Group"; | | "Shared Risk Ling Group"; |
| } | | } |
| } | | } |
| } | | } |
| container flex-algo { | | container flex-algo { |
| description | | description |
| "Flex-Algo Application"; | | "Flex-Algo Application"; |
| container link-attributes { | | container link-attributes { |
| description | | description |
| "Application Specific Link Attributes"; | | "Application Specific Link Attributes"; |
| container srlg { | | container srlg { |
| presence "Indicates a srlg node is configured."; | | presence "Indicates a srlg node is configured."; |
| description | | description |
| "Shared Risk Ling Group"; | | "Shared Risk Ling Group"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container ucmp { | | container ucmp { |
| description | | description |
| "UnEqual Cost Multipath feature"; | | "UnEqual Cost Multipath feature"; |
| container variance { | | container variance { |
| presence "Indicates a variance node is configured."; | | presence "Indicates a variance node is configured."; |
| description | | description |
| "Specify Variance parameter to filter UCMP paths based on cost"; | | "Specify Variance parameter to filter UCMP paths based on cost"; |
| leaf variance-value { | | leaf variance-value { |
| type uint32 { | | type uint32 { |
| range "101..10000" { | | range "101..10000" { |
| description | | description |
| "Variance value"; | | "Variance value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify Variance parameter to filter UCMP paths based on cost"; | | "Specify Variance parameter to filter UCMP paths based on cost"; |
| } | | } |
| leaf prefix-list { | | leaf prefix-list { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Name of the prefix-list"; | | "Name of the prefix-list"; |
| } | | } |
| } | | } |
| description | | description |
| "Specify prefix-list name to filter UCMP paths based on prefixes"; | | "Specify prefix-list name to filter UCMP paths based on prefixes"; |
| } | | } |
| } | | } |
| container exclude { | | container exclude { |
| description | | description |
| "UCMP interface exclusion information"; | | "UCMP interface exclusion information"; |
| container interfaces { | | container interfaces { |
| description | | description |
| "Exclude an interface from UCMP computation"; | | "Exclude an interface from UCMP computation"; |
| list interface { | | list interface { |
| key "interface-name"; | | key "interface-name"; |
| description | | description |
| "Exclude an interface from UCMP computation"; | | "Exclude an interface from UCMP computation"; |
| leaf interface-name { | | leaf interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Exclude an interface from UCMP computation"; | | "Exclude an interface from UCMP computation"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| leaf delay-interval { | | leaf delay-interval { |
| type uint32 { | | type uint32 { |
| range "100..65535" { | | range "100..65535" { |
| description | | description |
| "Delay interval value in milliseconds"; | | "Delay interval value in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "UCMP delay interval"; | | "UCMP delay interval"; |
| } | | } |
| } | | } |
| container microloop { | | container microloop { |
| description | | description |
| "Enable microloop protection feature"; | | "Enable microloop protection feature"; |
| container avoidance { | | container avoidance { |
| presence "Indicates a avoidance node is configured."; | | presence "Indicates a avoidance node is configured."; |
| description | | description |
| "Enable local microloop avoidance"; | | "Enable local microloop avoidance"; |
| container protected { | | container protected { |
| must "not(../segment-routing)"; | | must "not(../segment-routing)"; |
| presence "Indicates a protected node is configured."; | | presence "Indicates a protected node is configured."; |
| description | | description |
| "Enable microloop avoidance for only protected prefixes"; | | "Enable microloop avoidance for only protected prefixes"; |
| } | | } |
| container segment-routing { | | container segment-routing { |
| must "not(../protected)"; | | must "not(../protected)"; |
| presence "Indicates a segment-routing node is configured."; | | presence "Indicates a segment-routing node is configured."; |
| description | | description |
| "Enable segment routing microloop avoidance "; | | "Enable segment routing microloop avoidance "; |
| } | | } |
| } | | } |
| leaf avoidance-rib-update-delay { | | leaf avoidance-rib-update-delay { |
| type uint32 { | | type uint32 { |
| range "1000..65535" { | | range "1000..65535" { |
| description | | description |
| "Set value of delay"; | | "Set value of delay"; |
| } | | } |
| } | | } |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| container apply-weight { | | container apply-weight { |
| description | | description |
| "Apply weight"; | | "Apply weight"; |
| container ecmp-only { | | container ecmp-only { |
| must "not(../ucmp-only)"; | | must "not(../ucmp-only)"; |
| presence "Indicates a ecmp-only node is configured."; | | presence "Indicates a ecmp-only node is configured."; |
| description | | description |
| "Apply weights to ecmp paths only"; | | "Apply weights to ecmp paths only"; |
| container bandwidth { | | container bandwidth { |
| presence "Indicates a bandwidth node is configured."; | | presence "Indicates a bandwidth node is configured."; |
| description | | description |
| "Apply weight calculated based on interface bandwidth"; | | "Apply weight calculated based on interface bandwidth"; |
| } | | } |
| } | | } |
| container ucmp-only { | | container ucmp-only { |
| must "not(../ecmp-only)"; | | must "not(../ecmp-only)"; |
| presence "Indicates a ucmp-only node is configured."; | | presence "Indicates a ucmp-only node is configured."; |
| description | | description |
| "Apply weights to ucmp paths only"; | | "Apply weights to ucmp paths only"; |
| } | | } |
| } | | } |
| container summary-prefixes { | | container summary-prefixes { |
| description | | description |
| "Configure IP address prefixes"; | | "Configure IP address prefixes"; |
| list summary-prefix { | | list summary-prefix { |
| key "address-prefix"; | | key "address-prefix"; |
| description | | description |
| "Summary prefix"; | | "Summary prefix"; |
| leaf address-prefix { | | leaf address-prefix { |
| type inet:ip-prefix; | | type inet:ip-prefix; |
| description | | description |
| "Specify prefix associated with this Prefix Segement ID"; | | "Specify prefix associated with this Prefix Segement ID"; |
| } | | } |
| leaf tag { | | leaf tag { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "The tag value"; | | "The tag value"; |
| } | | } |
| } | | } |
| description | | description |
| "Set a tag"; | | "Set a tag"; |
| } | | } |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Summarize routes in one level only"; | | "Summarize routes in one level only"; |
| } | | } |
| leaf algorithm { | | leaf algorithm { |
| when "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'"; | | when "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'"; |
| type uint32 { | | type uint32 { |
| range "128..255"; | | range "128..255"; |
| } | | } |
| description | | description |
| "Flexible Algorithm number"; | | "Flexible Algorithm number"; |
| } | | } |
| container explicit { | | container explicit { |
| when "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'"; | | when "../../../af-name = 'ipv6' and ../../../saf-name = 'unicast'"; |
| presence "Indicates a explicit node is configured."; | | presence "Indicates a explicit node is configured."; |
| description | | description |
| "Strict flex-algo locator summarization mode"; | | "Strict flex-algo locator summarization mode"; |
| } | | } |
| } | | } |
| } | | } |
| container metric { | | container metric { |
| description | | description |
| "Configure default metric"; | | "Configure default metric"; |
| container default-metric { | | container default-metric { |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| leaf default-metric-value { | | leaf default-metric-value { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set metric at this level only"; | | "Set metric at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| } | | } |
| leaf default-metric-value { | | leaf default-metric-value { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container metric-style { | | container metric-style { |
| description | | description |
| "Use old-style (ISO 10589) or new-style packet formats"; | | "Use old-style (ISO 10589) or new-style packet formats"; |
| container narrow { | | container narrow { |
| must "not(../wide or ../transition)"; | | must "not(../wide or ../transition)"; |
| presence "Indicates a narrow node is configured."; | | presence "Indicates a narrow node is configured."; |
| description | | description |
| "Use old style of TLVs with narrow metric"; | | "Use old style of TLVs with narrow metric"; |
| } | | } |
| container wide { | | container wide { |
| must "not(../narrow or ../transition)"; | | must "not(../narrow or ../transition)"; |
| presence "Indicates a wide node is configured."; | | presence "Indicates a wide node is configured."; |
| description | | description |
| "Use new style of TLVs to carry wider metric"; | | "Use new style of TLVs to carry wider metric"; |
| } | | } |
| container transition { | | container transition { |
| must "not(../narrow or ../wide)"; | | must "not(../narrow or ../wide)"; |
| presence "Indicates a transition node is configured."; | | presence "Indicates a transition node is configured."; |
| description | | description |
| "Send and accept both styles of TLVs during transition"; | | "Send and accept both styles of TLVs during transition"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set metric-style for one level only"; | | "Set metric-style for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric-style for one level only"; | | "Set metric-style for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric-style for one level only"; | | "Set metric-style for one level only"; |
| } | | } |
| container narrow { | | container narrow { |
| must "not(../wide or ../transition)"; | | must "not(../wide or ../transition)"; |
| presence "Indicates a narrow node is configured."; | | presence "Indicates a narrow node is configured."; |
| description | | description |
| "Use old style of TLVs with narrow metric"; | | "Use old style of TLVs with narrow metric"; |
| } | | } |
| container wide { | | container wide { |
| must "not(../narrow or ../transition)"; | | must "not(../narrow or ../transition)"; |
| presence "Indicates a wide node is configured."; | | presence "Indicates a wide node is configured."; |
| description | | description |
| "Use new style of TLVs to carry wider metric"; | | "Use new style of TLVs to carry wider metric"; |
| } | | } |
| container transition { | | container transition { |
| must "not(../narrow or ../wide)"; | | must "not(../narrow or ../wide)"; |
| presence "Indicates a transition node is configured."; | | presence "Indicates a transition node is configured."; |
| description | | description |
| "Send and accept both styles of TLVs during transition"; | | "Send and accept both styles of TLVs during transition"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container spf-interval { | | container spf-interval { |
| description | | description |
| "Route calculation scheduling parameters (FSPF, ISPF, PRC)"; | | "Route calculation scheduling parameters (FSPF, ISPF, PRC)"; |
| n | container ietf { | n | |
| presence "Indicates a ietf node is configured."; | | |
| description | | |
| "Use RFC 8405 backoff algorithm"; | | |
| leaf initial-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Initial delay before running a route calculation"; | | |
| } | | |
| leaf short-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Short delay before running a route calculation"; | | |
| } | | |
| leaf long-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Long delay before running a route calculation"; | | |
| } | | |
| leaf learn-interval-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Time To Learn interval for running a route calculation"; | | |
| } | | |
| leaf holddown-interval-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Holddown interval for running a route calculation"; | | |
| } | | |
| } | | |
| container maximum-wait { | | container maximum-wait { |
| description | | description |
| "Maximum delay before running a route calculation"; | | "Maximum delay before running a route calculation"; |
| leaf maximum-wait-time { | | leaf maximum-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum delay before running a route calculation"; | | "Maximum delay before running a route calculation"; |
| } | | } |
| } | | } |
| container initial-wait { | | container initial-wait { |
| description | | description |
| "Initial delay before running a route calculation"; | | "Initial delay before running a route calculation"; |
| leaf initial-wait-time { | | leaf initial-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Initial delay before running a route calculation"; | | "Initial delay before running a route calculation"; |
| } | | } |
| } | | } |
| container secondary-wait { | | container secondary-wait { |
| description | | description |
| "Secondary delay before running a route calculation"; | | "Secondary delay before running a route calculation"; |
| leaf secondary-wait-time { | | leaf secondary-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Secondary delay before running a route calculation"; | | "Secondary delay before running a route calculation"; |
| } | | } |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set SPF interval for one level only"; | | "Set SPF interval for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set SPF interval for one level only"; | | "Set SPF interval for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set SPF interval for one level only"; | | "Set SPF interval for one level only"; |
| n | } | n | |
| container ietf { | | |
| presence "Indicates a ietf node is configured."; | | |
| description | | |
| "Use RFC 8405 backoff algorithm"; | | |
| leaf initial-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Initial delay before running a route calculation"; | | |
| } | | |
| leaf short-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Short delay before running a route calculation"; | | |
| } | | |
| leaf long-wait-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Long delay before running a route calculation"; | | |
| } | | |
| leaf learn-interval-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Time To Learn interval for running a route calculation"; | | |
| } | | |
| leaf holddown-interval-time { | | |
| type uint32 { | | |
| range "0..120000" { | | |
| description | | |
| "Delay in milliseconds"; | | |
| } | | |
| } | | |
| description | | |
| "Holddown interval for running a route calculation"; | | |
| } | | |
| } | | } |
| leaf maximum-wait-time { | | leaf maximum-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum delay before running a route calculation"; | | "Maximum delay before running a route calculation"; |
| } | | } |
| leaf secondary-wait-time { | | leaf secondary-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Secondary delay before running a route calculation"; | | "Secondary delay before running a route calculation"; |
| } | | } |
| leaf initial-wait-time { | | leaf initial-wait-time { |
| type uint32 { | | type uint32 { |
| range "0..120000" { | | range "0..120000" { |
| description | | description |
| "Delay in milliseconds"; | | "Delay in milliseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Initial delay before running a route calculation"; | | "Initial delay before running a route calculation"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container spf { | | container spf { |
| description | | description |
| "SPF configuration"; | | "SPF configuration"; |
| container periodic { | | container periodic { |
| description | | description |
| "Configure the periodic SPF"; | | "Configure the periodic SPF"; |
| leaf interval { | | leaf interval { |
| type union { | | type union { |
| type enumeration { | | type enumeration { |
| enum "disable-periodic-spf" { | | enum "disable-periodic-spf" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the periodic SPF (spf periodic disable)"; | | "Disable the periodic SPF (spf periodic disable)"; |
| } | | } |
| } | | } |
| type uint32 { | | type uint32 { |
| range "1..3600" { | | range "1..3600" { |
| description | | description |
| "Maximum interval in between SPF runs in seconds(spf periodic interval <value>)"; | | "Maximum interval in between SPF runs in seconds(spf periodic interval <value>)"; |
| } | | } |
| } | | } |
| } | | } |
| description | | description |
| "Set the maximum interval in between SPF runs"; | | "Set the maximum interval in between SPF runs"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure periodic SPF interval for for one level only"; | | "Configure periodic SPF interval for for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure periodic SPF interval for for one level only"; | | "Configure periodic SPF interval for for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure periodic SPF interval for for one level only"; | | "Configure periodic SPF interval for for one level only"; |
| } | | } |
| leaf interval { | | leaf interval { |
| type union { | | type union { |
| type enumeration { | | type enumeration { |
| enum "disable-periodic-spf" { | | enum "disable-periodic-spf" { |
| value 0; | | value 0; |
| description | | description |
| "Disable the periodic SPF (spf periodic disable)"; | | "Disable the periodic SPF (spf periodic disable)"; |
| } | | } |
| } | | } |
| type uint32 { | | type uint32 { |
| range "1..3600" { | | range "1..3600" { |
| description | | description |
| "Maximum interval in between SPF runs in seconds(spf periodic interval <value>)"; | | "Maximum interval in between SPF runs in seconds(spf periodic interval <value>)"; |
| } | | } |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set the maximum interval in between SPF runs"; | | "Set the maximum interval in between SPF runs"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container prefix-priority { | | container prefix-priority { |
| description | | description |
| "Configure a prefix priority list"; | | "Configure a prefix priority list"; |
| list prefix-priority { | | list prefix-priority { |
| must "tag or access-list-name"; | | must "tag or access-list-name"; |
| key "priority"; | | key "priority"; |
| description | | description |
| "Configure a prefix priority list"; | | "Configure a prefix priority list"; |
| leaf priority { | | leaf priority { |
| type enumeration { | | type enumeration { |
| enum "critical" { | | enum "critical" { |
| value 0; | | value 0; |
| description | | description |
| "Specify critical priority prefixes"; | | "Specify critical priority prefixes"; |
| } | | } |
| enum "high" { | | enum "high" { |
| value 1; | | value 1; |
| description | | description |
| "Specify high priority prefixes"; | | "Specify high priority prefixes"; |
| } | | } |
| enum "medium" { | | enum "medium" { |
| value 2; | | value 2; |
| description | | description |
| "Specify medium priority prefixes"; | | "Specify medium priority prefixes"; |
| } | | } |
| } | | } |
| description | | description |
| "prefix priority"; | | "prefix priority"; |
| } | | } |
| leaf tag { | | leaf tag { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "The tag to indicate priority"; | | "The tag to indicate priority"; |
| } | | } |
| } | | } |
| must "not(../access-list-name)"; | | must "not(../access-list-name)"; |
| description | | description |
| "Specify a tag to indicate priority"; | | "Specify a tag to indicate priority"; |
| } | | } |
| leaf access-list-name { | | leaf access-list-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Access-list name"; | | "Access-list name"; |
| } | | } |
| } | | } |
| must "not(../tag)"; | | must "not(../tag)"; |
| description | | description |
| "Access-list name"; | | "Access-list name"; |
| } | | } |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure SPF prefix priority list for one level only"; | | "Configure SPF prefix priority list for one level only"; |
| list level { | | list level { |
| must "tag or access-list-name"; | | must "tag or access-list-name"; |
| key "level-id priority"; | | key "level-id priority"; |
| description | | description |
| "Configure SPF prefix priority list for one level only"; | | "Configure SPF prefix priority list for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure SPF prefix priority list for one level only"; | | "Configure SPF prefix priority list for one level only"; |
| } | | } |
| leaf priority { | | leaf priority { |
| type enumeration { | | type enumeration { |
| enum "critical" { | | enum "critical" { |
| value 0; | | value 0; |
| description | | description |
| "Specify critical priority prefixes"; | | "Specify critical priority prefixes"; |
| } | | } |
| enum "high" { | | enum "high" { |
| value 1; | | value 1; |
| description | | description |
| "Specify high priority prefixes"; | | "Specify high priority prefixes"; |
| } | | } |
| enum "medium" { | | enum "medium" { |
| value 2; | | value 2; |
| description | | description |
| "Specify medium priority prefixes"; | | "Specify medium priority prefixes"; |
| } | | } |
| } | | } |
| description | | description |
| "prefix priority"; | | "prefix priority"; |
| } | | } |
| leaf tag { | | leaf tag { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "The tag to indicate priority"; | | "The tag to indicate priority"; |
| } | | } |
| } | | } |
| must "not(../access-list-name)"; | | must "not(../access-list-name)"; |
| description | | description |
| "Specify a tag to indicate priority"; | | "Specify a tag to indicate priority"; |
| } | | } |
| leaf access-list-name { | | leaf access-list-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Access-list name"; | | "Access-list name"; |
| } | | } |
| } | | } |
| must "not(../tag)"; | | must "not(../tag)"; |
| description | | description |
| "Access-list name"; | | "Access-list name"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container maximum-redistributed-prefixes { | | container maximum-redistributed-prefixes { |
| description | | description |
| "Maximum number of redistributed prefixes"; | | "Maximum number of redistributed prefixes"; |
| leaf maximum-prefixes { | | leaf maximum-prefixes { |
| type uint32 { | | type uint32 { |
| range "1..28000" { | | range "1..28000" { |
| description | | description |
| "maximum limit on number of redistributed prefixes"; | | "maximum limit on number of redistributed prefixes"; |
| } | | } |
| } | | } |
| description | | description |
| "Maximum number of redistributed prefixes"; | | "Maximum number of redistributed prefixes"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set maximum redistributed prefixes for one level only"; | | "Set maximum redistributed prefixes for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set maximum redistributed prefixes for one level only"; | | "Set maximum redistributed prefixes for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set maximum redistributed prefixes for one level only"; | | "Set maximum redistributed prefixes for one level only"; |
| } | | } |
| leaf maximum-prefixes { | | leaf maximum-prefixes { |
| type uint32 { | | type uint32 { |
| range "1..28000" { | | range "1..28000" { |
| description | | description |
| "maximum limit on number of redistributed prefixes"; | | "maximum limit on number of redistributed prefixes"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Maximum number of redistributed prefixes"; | | "Maximum number of redistributed prefixes"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container propagates { | | container propagates { |
| description | | description |
| "Propagate routes between IS-IS levels"; | | "Propagate routes between IS-IS levels"; |
| list propagate { | | list propagate { |
| key "level into-level"; | | key "level into-level"; |
| description | | description |
| "Source level"; | | "Source level"; |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| n | description | n | |
| "level"; | | |
| } | | } |
| leaf into-level { | | leaf into-level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Destination level"; | | "Destination level"; |
| } | | } |
| } | | } |
| description | | description |
| "into"; | | "into"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| mandatory true; | | mandatory true; |
| description | | description |
| "Propagate only specified routes"; | | "Propagate only specified routes"; |
| } | | } |
| } | | } |
| } | | } |
| container adjacency-check { | | container adjacency-check { |
| description | | description |
| "Suppress checking of consistent AF support on received IIHs"; | | "Suppress checking of consistent AF support on received IIHs"; |
| container disable { | | container disable { |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable adjacency-checking"; | | "Disable adjacency-checking"; |
| } | | } |
| } | | } |
| container route { | | container route { |
| description | | description |
| "Control the advertisement of routes in the RIB"; | | "Control the advertisement of routes in the RIB"; |
| container source { | | container source { |
| description | | description |
| "Control the path source value"; | | "Control the path source value"; |
| container first-hop { | | container first-hop { |
| presence "Indicates a first-hop node is configured."; | | presence "Indicates a first-hop node is configured."; |
| description | | description |
| "Use the IP address of the first-hop"; | | "Use the IP address of the first-hop"; |
| } | | } |
| } | | } |
| } | | } |
| container attached-bit { | | container attached-bit { |
| description | | description |
| "Modify behavior of the attached-bit"; | | "Modify behavior of the attached-bit"; |
| container send { | | container send { |
| description | | description |
| "Modify how we set the attached bit"; | | "Modify how we set the attached bit"; |
| container always-set { | | container always-set { |
| must "not(../never-set)"; | | must "not(../never-set)"; |
| presence "Indicates a always-set node is configured."; | | presence "Indicates a always-set node is configured."; |
| description | | description |
| "Always set the attached bit in our LSP"; | | "Always set the attached bit in our LSP"; |
| } | | } |
| container never-set { | | container never-set { |
| must "not(../always-set)"; | | must "not(../always-set)"; |
| presence "Indicates a never-set node is configured."; | | presence "Indicates a never-set node is configured."; |
| description | | description |
| "Never set the attached bit our LSP"; | | "Never set the attached bit our LSP"; |
| } | | } |
| } | | } |
| container receive { | | container receive { |
| description | | description |
| "Modify how we treat received attached bits"; | | "Modify how we treat received attached bits"; |
| container ignore { | | container ignore { |
| presence "Indicates a ignore node is configured."; | | presence "Indicates a ignore node is configured."; |
| description | | description |
| "Ignore the attached bit in received LSPs"; | | "Ignore the attached bit in received LSPs"; |
| } | | } |
| } | | } |
| } | | } |
| leaf topology-id { | | leaf topology-id { |
| type uint32 { | | type uint32 { |
| range "6..4095" { | | range "6..4095" { |
| description | | description |
| "The IS-IS MT ID to identify the topology"; | | "The IS-IS MT ID to identify the topology"; |
| } | | } |
| } | | } |
| description | | description |
| "Specify the IS-IS MT ID for this topology"; | | "Specify the IS-IS MT ID for this topology"; |
| } | | } |
| container fast-reroute { | | container fast-reroute { |
| description | | description |
| "Configure Fast ReRoute"; | | "Configure Fast ReRoute"; |
| leaf delay-interval { | | leaf delay-interval { |
| type uint32 { | | type uint32 { |
| range "100..60000" { | | range "100..60000" { |
| description | | description |
| "Delay before running FRR (milliseconds)"; | | "Delay before running FRR (milliseconds)"; |
| } | | } |
| } | | } |
| description | | description |
| "Delay before running FRR computation"; | | "Delay before running FRR computation"; |
| } | | } |
| } | | } |
| container monitor-convergence { | | container monitor-convergence { |
| presence "Indicates a monitor-convergence node is configured."; | | presence "Indicates a monitor-convergence node is configured."; |
| description | | description |
| "Enables convergence monitoring"; | | "Enables convergence monitoring"; |
| leaf prefix-list { | | leaf prefix-list { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "Prefix List Name"; | | "Prefix List Name"; |
| } | | } |
| } | | } |
| description | | description |
| "Enables Individual Prefix Monitoring"; | | "Enables Individual Prefix Monitoring"; |
| } | | } |
| container track-ip-frr { | | container track-ip-frr { |
| presence "Indicates a track-ip-frr node is configured."; | | presence "Indicates a track-ip-frr node is configured."; |
| description | | description |
| "Enables Tracking IP-Frr Convergence"; | | "Enables Tracking IP-Frr Convergence"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container interfaces { | | container interfaces { |
| description | | description |
| "Enter the IS-IS interface configuration submode"; | | "Enter the IS-IS interface configuration submode"; |
| list interface { | | list interface { |
| key "interface-name"; | | key "interface-name"; |
| description | | description |
| "Enter the IS-IS interface configuration submode"; | | "Enter the IS-IS interface configuration submode"; |
| leaf interface-name { | | leaf interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Enter the IS-IS interface configuration submode"; | | "Enter the IS-IS interface configuration submode"; |
| } | | } |
| leaf circuit-type { | | leaf circuit-type { |
| type enumeration { | | type enumeration { |
| enum "level-1" { | | enum "level-1" { |
| value 1; | | value 1; |
| description | | description |
| "Form level-1 adjacencies only"; | | "Form level-1 adjacencies only"; |
| } | | } |
| enum "level-2-only" { | | enum "level-2-only" { |
| value 2; | | value 2; |
| description | | description |
| "Form level-2 adjacencies only"; | | "Form level-2 adjacencies only"; |
| } | | } |
| enum "level-1-2" { | | enum "level-1-2" { |
| value 3; | | value 3; |
| description | | description |
| "Form level-1 and level-2 adjacencies"; | | "Form level-1 and level-2 adjacencies"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure circuit type for interface"; | | "Configure circuit type for interface"; |
| } | | } |
| container csnp-interval { | | container csnp-interval { |
| description | | description |
| "Set CSNP interval"; | | "Set CSNP interval"; |
| leaf csnp-interval-time { | | leaf csnp-interval-time { |
| type uint32 { | | type uint32 { |
| range "0..65535" { | | range "0..65535" { |
| description | | description |
| "CSNP interval value (seconds)"; | | "CSNP interval value (seconds)"; |
| } | | } |
| } | | } |
| description | | description |
| "Set CSNP interval"; | | "Set CSNP interval"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set the CSNP interval only at the supplied level"; | | "Set the CSNP interval only at the supplied level"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set the CSNP interval only at the supplied level"; | | "Set the CSNP interval only at the supplied level"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set the CSNP interval only at this level"; | | "Set the CSNP interval only at this level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set the CSNP interval only at the supplied level"; | | "Set the CSNP interval only at the supplied level"; |
| } | | } |
| leaf csnp-interval-time { | | leaf csnp-interval-time { |
| type uint32 { | | type uint32 { |
| range "0..65535" { | | range "0..65535" { |
| description | | description |
| "CSNP interval value (seconds)"; | | "CSNP interval value (seconds)"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set CSNP interval"; | | "Set CSNP interval"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container hello-padding { | | container hello-padding { |
| description | | description |
| "Add padding to IS-IS hello packets"; | | "Add padding to IS-IS hello packets"; |
| n | container always { | n | |
| must "not(../disable or ../sometimes)"; | | |
| presence "Indicates a always node is configured."; | | |
| description | | |
| "Always enable hello-padding"; | | |
| } | | |
| container disable { | | container disable { |
| must "not(../sometimes)"; | | must "not(../sometimes)"; |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable hello-padding"; | | "Disable hello-padding"; |
| } | | } |
| container sometimes { | | container sometimes { |
| must "not(../disable)"; | | must "not(../disable)"; |
| presence "Indicates a sometimes node is configured."; | | presence "Indicates a sometimes node is configured."; |
| description | | description |
| "Enable hello-padding during adjacency formation only"; | | "Enable hello-padding during adjacency formation only"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set hello-interval for one level only"; | | "Set hello-interval for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set hello-interval for one level only"; | | "Set hello-interval for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set hello-interval for IIHs at this level only"; | | "Set hello-interval for IIHs at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set hello-interval for one level only"; | | "Set hello-interval for one level only"; |
| } | | } |
| container disable { | | container disable { |
| must "not(../sometimes)"; | | must "not(../sometimes)"; |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable hello-padding"; | | "Disable hello-padding"; |
| } | | } |
| container sometimes { | | container sometimes { |
| must "not(../disable)"; | | must "not(../disable)"; |
| presence "Indicates a sometimes node is configured."; | | presence "Indicates a sometimes node is configured."; |
| description | | description |
| "Enable hello-padding during adjacency formation only"; | | "Enable hello-padding during adjacency formation only"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container hello-interval { | | container hello-interval { |
| description | | description |
| "Set Hello interval in seconds"; | | "Set Hello interval in seconds"; |
| leaf hello-interval-time { | | leaf hello-interval-time { |
| type uint32 { | | type uint32 { |
| range "1..65535" { | | range "1..65535" { |
| description | | description |
| "Hello interval value"; | | "Hello interval value"; |
| } | | } |
| } | | } |
| description | | description |
| "Set Hello interval in seconds"; | | "Set Hello interval in seconds"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set hello-interval for one level only"; | | "Set hello-interval for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set hello-interval for one level only"; | | "Set hello-interval for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set hello-interval for IIHs at this level only"; | | "Set hello-interval for IIHs at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set hello-interval for one level only"; | | "Set hello-interval for one level only"; |
| } | | } |
| leaf hello-interval-time { | | leaf hello-interval-time { |
| type uint32 { | | type uint32 { |
| range "1..65535" { | | range "1..65535" { |
| description | | description |
| "Hello interval value"; | | "Hello interval value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set Hello interval in seconds"; | | "Set Hello interval in seconds"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container hello-multiplier { | | container hello-multiplier { |
| description | | description |
| "Set multiplier for Hello holding time"; | | "Set multiplier for Hello holding time"; |
| leaf hello-multiplier-value { | | leaf hello-multiplier-value { |
| type uint32 { | | type uint32 { |
| range "3..1000" { | | range "3..1000" { |
| description | | description |
| "Hello multiplier value"; | | "Hello multiplier value"; |
| } | | } |
| } | | } |
| description | | description |
| "Set multiplier for Hello holding time"; | | "Set multiplier for Hello holding time"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set hello-multiplier for one level only"; | | "Set hello-multiplier for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set hello-multiplier for one level only"; | | "Set hello-multiplier for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set hello-multiplier for IIHs at this level only"; | | "Set hello-multiplier for IIHs at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set hello-multiplier for one level only"; | | "Set hello-multiplier for one level only"; |
| } | | } |
| leaf hello-multiplier-value { | | leaf hello-multiplier-value { |
| type uint32 { | | type uint32 { |
| range "3..1000" { | | range "3..1000" { |
| description | | description |
| "Hello multiplier value"; | | "Hello multiplier value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set multiplier for Hello holding time"; | | "Set multiplier for Hello holding time"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container lsp-interval { | | container lsp-interval { |
| description | | description |
| "Set LSP transmission interval"; | | "Set LSP transmission interval"; |
| leaf lsp-interval-time { | | leaf lsp-interval-time { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "LSP transmission interval (milliseconds)"; | | "LSP transmission interval (milliseconds)"; |
| } | | } |
| } | | } |
| description | | description |
| "Set LSP transmission interval"; | | "Set LSP transmission interval"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "set lsp-interval for this level"; | | "set lsp-interval for this level"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "set lsp-interval for this level"; | | "set lsp-interval for this level"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set lsp-interval at this level only"; | | "Set lsp-interval at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "set lsp-interval for this level"; | | "set lsp-interval for this level"; |
| } | | } |
| leaf lsp-interval-time { | | leaf lsp-interval-time { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "LSP transmission interval (milliseconds)"; | | "LSP transmission interval (milliseconds)"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set LSP transmission interval"; | | "Set LSP transmission interval"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container hello-password { | | container hello-password { |
| must "text or hmac-md5 or keychain"; | | must "text or hmac-md5 or keychain"; |
| presence "Indicates a hello-password node is configured."; | | presence "Indicates a hello-password node is configured."; |
| description | | description |
| "Configure the IIH password"; | | "Configure the IIH password"; |
| container text { | | container text { |
| must "not(../hmac-md5 or ../keychain)"; | | must "not(../hmac-md5 or ../keychain)"; |
| presence "Indicates a text node is configured."; | | presence "Indicates a text node is configured."; |
| description | | description |
| "Use cleartext password authentication"; | | "Use cleartext password authentication"; |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| mandatory true; | | mandatory true; |
| description | | description |
| "The encrypted LSP/SNP password"; | | "The encrypted LSP/SNP password"; |
| } | | } |
| } | | } |
| container hmac-md5 { | | container hmac-md5 { |
| must "not(../text or ../keychain)"; | | must "not(../text or ../keychain)"; |
| presence "Indicates a hmac-md5 node is configured."; | | presence "Indicates a hmac-md5 node is configured."; |
| description | | description |
| "Use HMAC-MD5 authentication"; | | "Use HMAC-MD5 authentication"; |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| mandatory true; | | mandatory true; |
| description | | description |
| "The encrypted LSP/SNP password"; | | "The encrypted LSP/SNP password"; |
| } | | } |
| } | | } |
| container keychain { | | container keychain { |
| must "not(../text or ../hmac-md5)"; | | must "not(../text or ../hmac-md5)"; |
| presence "Indicates a keychain node is configured."; | | presence "Indicates a keychain node is configured."; |
| description | | description |
| "Specifies a Key Chain name will follow"; | | "Specifies a Key Chain name will follow"; |
| leaf keychain-name { | | leaf keychain-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "The Key Chain name"; | | "The Key Chain name"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specifies a Key Chain name will follow"; | | "Specifies a Key Chain name will follow"; |
| } | | } |
| } | | } |
| container send-only { | | container send-only { |
| presence "Indicates a send-only node is configured."; | | presence "Indicates a send-only node is configured."; |
| description | | description |
| "Do not require authentication of incoming IIHs"; | | "Do not require authentication of incoming IIHs"; |
| } | | } |
| } | | } |
| container hello-password-levels { | | container hello-password-levels { |
| description | | description |
| "Set hello-password for one level only"; | | "Set hello-password for one level only"; |
| list level { | | list level { |
| must "text or hmac-md5 or keychain"; | | must "text or hmac-md5 or keychain"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set hello-password for one level only"; | | "Set hello-password for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set hello-password for IIHs at this level only"; | | "Set hello-password for IIHs at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set hello-password for one level only"; | | "Set hello-password for one level only"; |
| } | | } |
| container text { | | container text { |
| must "not(../hmac-md5 or ../keychain)"; | | must "not(../hmac-md5 or ../keychain)"; |
| presence "Indicates a text node is configured."; | | presence "Indicates a text node is configured."; |
| description | | description |
| "Use cleartext password authentication"; | | "Use cleartext password authentication"; |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| mandatory true; | | mandatory true; |
| description | | description |
| "The encrypted LSP/SNP password"; | | "The encrypted LSP/SNP password"; |
| } | | } |
| } | | } |
| container hmac-md5 { | | container hmac-md5 { |
| must "not(../text or ../keychain)"; | | must "not(../text or ../keychain)"; |
| presence "Indicates a hmac-md5 node is configured."; | | presence "Indicates a hmac-md5 node is configured."; |
| description | | description |
| "Use HMAC-MD5 authentication"; | | "Use HMAC-MD5 authentication"; |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| mandatory true; | | mandatory true; |
| description | | description |
| "The encrypted LSP/SNP password"; | | "The encrypted LSP/SNP password"; |
| } | | } |
| } | | } |
| container keychain { | | container keychain { |
| must "not(../text or ../hmac-md5)"; | | must "not(../text or ../hmac-md5)"; |
| presence "Indicates a keychain node is configured."; | | presence "Indicates a keychain node is configured."; |
| description | | description |
| "Specifies a Key Chain name will follow"; | | "Specifies a Key Chain name will follow"; |
| leaf keychain-name { | | leaf keychain-name { |
| type string { | | type string { |
| length "1..1024" { | | length "1..1024" { |
| description | | description |
| "The Key Chain name"; | | "The Key Chain name"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specifies a Key Chain name will follow"; | | "Specifies a Key Chain name will follow"; |
| } | | } |
| } | | } |
| container send-only { | | container send-only { |
| presence "Indicates a send-only node is configured."; | | presence "Indicates a send-only node is configured."; |
| description | | description |
| "Do not require authentication of incoming IIHs"; | | "Do not require authentication of incoming IIHs"; |
| } | | } |
| } | | } |
| } | | } |
| container hello-password-accept { | | container hello-password-accept { |
| description | | description |
| "Use password for incoming authentication only"; | | "Use password for incoming authentication only"; |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| description | | description |
| "The encrypted hello password"; | | "The encrypted hello password"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set hello-password for one level only"; | | "Set hello-password for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set hello-password for one level only"; | | "Set hello-password for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set hello-password for IIHs at this level only"; | | "Set hello-password for IIHs at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set hello-password for one level only"; | | "Set hello-password for one level only"; |
| } | | } |
| leaf encrypted { | | leaf encrypted { |
| type xr:Proprietary-password; | | type xr:Proprietary-password; |
| mandatory true; | | mandatory true; |
| description | | description |
| "The encrypted hello password"; | | "The encrypted hello password"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container lsp { | | container lsp { |
| description | | description |
| "LSP configuration"; | | "LSP configuration"; |
| container fast-flood { | | container fast-flood { |
| description | | description |
| "LSP fast flood configuration"; | | "LSP fast flood configuration"; |
| container threshold { | | container threshold { |
| description | | description |
| "Set LSP transmission fast flood threshold"; | | "Set LSP transmission fast flood threshold"; |
| leaf number-of-lsps { | | leaf number-of-lsps { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "Number of LSPs to send back to back"; | | "Number of LSPs to send back to back"; |
| } | | } |
| } | | } |
| description | | description |
| "Set LSP transmission fast flood threshold"; | | "Set LSP transmission fast flood threshold"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set lsp fast-flood threshold for this level"; | | "Set lsp fast-flood threshold for this level"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set lsp fast-flood threshold for this level"; | | "Set lsp fast-flood threshold for this level"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set lsp fast-flood threshold at this level only"; | | "Set lsp fast-flood threshold at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set lsp fast-flood threshold for this level"; | | "Set lsp fast-flood threshold for this level"; |
| } | | } |
| leaf number-of-lsps { | | leaf number-of-lsps { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "Number of LSPs to send back to back"; | | "Number of LSPs to send back to back"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set LSP transmission fast flood threshold"; | | "Set LSP transmission fast flood threshold"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| n | leaf remote-psnp-delay { | n | |
| type uint32 { | | |
| range "1..10000" { | | |
| description | | |
| "remote PSNP delay (milliseconds), default is 500"; | | |
| } | | |
| } | | |
| description | | |
| "Set remote PSNP delay"; | | |
| } | | |
| container priority { | | container priority { |
| description | | description |
| "Set priority for Designated Router election"; | | "Set priority for Designated Router election"; |
| leaf priority-value { | | leaf priority-value { |
| type uint32 { | | type uint32 { |
| range "0..127" { | | range "0..127" { |
| description | | description |
| "Priority value"; | | "Priority value"; |
| } | | } |
| } | | } |
| description | | description |
| "Set priority for Designated Router election"; | | "Set priority for Designated Router election"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set priority for one level only"; | | "Set priority for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set priority for one level only"; | | "Set priority for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set priority for this level only"; | | "Set priority for this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set priority for one level only"; | | "Set priority for one level only"; |
| } | | } |
| leaf priority-value { | | leaf priority-value { |
| type uint32 { | | type uint32 { |
| range "0..127" { | | range "0..127" { |
| description | | description |
| "Priority value"; | | "Priority value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set priority for Designated Router election"; | | "Set priority for Designated Router election"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container point-to-point { | | container point-to-point { |
| presence "Indicates a point-to-point node is configured."; | | presence "Indicates a point-to-point node is configured."; |
| description | | description |
| "Treat active LAN interface as point-to-point"; | | "Treat active LAN interface as point-to-point"; |
| } | | } |
| container retransmit-interval { | | container retransmit-interval { |
| description | | description |
| "Interval between retransmissions of the same LSP"; | | "Interval between retransmissions of the same LSP"; |
| leaf retransmit-interval-time { | | leaf retransmit-interval-time { |
| type uint32 { | | type uint32 { |
| range "0..65535" { | | range "0..65535" { |
| description | | description |
| "(seconds)"; | | "(seconds)"; |
| } | | } |
| } | | } |
| description | | description |
| "Interval between retransmissions of the same LSP"; | | "Interval between retransmissions of the same LSP"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set retransmit-interval for one level only"; | | "Set retransmit-interval for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set retransmit-interval for one level only"; | | "Set retransmit-interval for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set retransmit-interval for LSPs at this level only"; | | "Set retransmit-interval for LSPs at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set retransmit-interval for one level only"; | | "Set retransmit-interval for one level only"; |
| } | | } |
| leaf retransmit-interval-time { | | leaf retransmit-interval-time { |
| type uint32 { | | type uint32 { |
| range "0..65535" { | | range "0..65535" { |
| description | | description |
| "(seconds)"; | | "(seconds)"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Interval between retransmissions of the same LSP"; | | "Interval between retransmissions of the same LSP"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container retransmit-throttle-interval { | | container retransmit-throttle-interval { |
| description | | description |
| "Minimum interval betwen retransissions of different LSPs"; | | "Minimum interval betwen retransissions of different LSPs"; |
| leaf retransmit-throttle-interval-time { | | leaf retransmit-throttle-interval-time { |
| type uint32 { | | type uint32 { |
| range "0..65535" { | | range "0..65535" { |
| description | | description |
| "(milliseconds)"; | | "(milliseconds)"; |
| } | | } |
| } | | } |
| description | | description |
| "Minimum interval betwen retransissions of different LSPs"; | | "Minimum interval betwen retransissions of different LSPs"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set retransmit-throttle-interval for one level only"; | | "Set retransmit-throttle-interval for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set retransmit-throttle-interval for one level only"; | | "Set retransmit-throttle-interval for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set retransmit-throttle-interval at this level only"; | | "Set retransmit-throttle-interval at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set retransmit-throttle-interval for one level only"; | | "Set retransmit-throttle-interval for one level only"; |
| } | | } |
| leaf retransmit-throttle-interval-time { | | leaf retransmit-throttle-interval-time { |
| type uint32 { | | type uint32 { |
| range "0..65535" { | | range "0..65535" { |
| description | | description |
| "(milliseconds)"; | | "(milliseconds)"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Minimum interval betwen retransissions of different LSPs"; | | "Minimum interval betwen retransissions of different LSPs"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container link-down { | | container link-down { |
| description | | description |
| "Configure interface down event parameters"; | | "Configure interface down event parameters"; |
| container fast-detect { | | container fast-detect { |
| presence "Indicates a fast-detect node is configured."; | | presence "Indicates a fast-detect node is configured."; |
| description | | description |
| "Enable high priority detection"; | | "Enable high priority detection"; |
| } | | } |
| } | | } |
| container prefix-attributes { | | container prefix-attributes { |
| when "../interface-name[starts-with(text(),'Loopback')]" { | | when "../interface-name[starts-with(text(),'Loopback')]" { |
| tailf:dependency "../interface-name"; | | tailf:dependency "../interface-name"; |
| } | | } |
| description | | description |
| "Set Prefix Attributes"; | | "Set Prefix Attributes"; |
| container n-flag-clear { | | container n-flag-clear { |
| presence "Indicates a n-flag-clear node is configured."; | | presence "Indicates a n-flag-clear node is configured."; |
| description | | description |
| "Clear N-flag"; | | "Clear N-flag"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Clear N-flag for this level"; | | "Clear N-flag for this level"; |
| list level { | | list level { |
| must "n-flag-clear"; | | must "n-flag-clear"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Clear N-flag for this level"; | | "Clear N-flag for this level"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Clear N-flag at this level only"; | | "Clear N-flag at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Clear N-flag for this level"; | | "Clear N-flag for this level"; |
| } | | } |
| container n-flag-clear { | | container n-flag-clear { |
| presence "Indicates a n-flag-clear node is configured."; | | presence "Indicates a n-flag-clear node is configured."; |
| description | | description |
| "Clear N-flag"; | | "Clear N-flag"; |
| } | | } |
| } | | } |
| } | | } |
| container anycast { | | container anycast { |
| presence "Indicates a anycast node is configured."; | | presence "Indicates a anycast node is configured."; |
| description | | description |
| "Prefix has anycast semantics"; | | "Prefix has anycast semantics"; |
| } | | } |
| container anycast-levels { | | container anycast-levels { |
| description | | description |
| "Set anycast for this level"; | | "Set anycast for this level"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set anycast for this level"; | | "Set anycast for this level"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set anycast at this level only"; | | "Set anycast at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set anycast for this level"; | | "Set anycast for this level"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container affinity { | | container affinity { |
| description | | description |
| "Application specific interface affinities"; | | "Application specific interface affinities"; |
| container flex-algos { | | container flex-algos { |
| description | | description |
| "Affinities for Flexible Algorithm application"; | | "Affinities for Flexible Algorithm application"; |
| leaf-list affinity-names { | | leaf-list affinity-names { |
| type string { | | type string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Affinity names"; | | "Affinity names"; |
| } | | } |
| } | | } |
| max-elements "32"; | | max-elements "32"; |
| description | | description |
| "Affinities for Flexible Algorithm application"; | | "Affinities for Flexible Algorithm application"; |
| n | } | n | |
| container anomalies { | | |
| description | | |
| "Affinities to advertise when there is a link anomaly"; | | |
| leaf-list anomaly { | | |
| type string { | | |
| length "1..32" { | | |
| description | | |
| "Affinity names"; | | |
| } | | |
| } | | |
| max-elements "32"; | | |
| description | | |
| "Affinities to advertise when there is a link anomaly"; | | |
| } | | |
| } | | } |
| } | | } |
| } | | } |
| container override { | | container override { |
| description | | description |
| "Override a configuration setting"; | | "Override a configuration setting"; |
| container metrics { | | container metrics { |
| description | | description |
| "Override the configured link metrics"; | | "Override the configured link metrics"; |
| container maximum { | | container maximum { |
| must "not(../high or ../disabled)"; | | must "not(../high or ../disabled)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set metric to unreachable value (wide metrics only)"; | | "Set metric to unreachable value (wide metrics only)"; |
| } | | } |
| container high { | | container high { |
| must "not(../maximum or ../disabled)"; | | must "not(../maximum or ../disabled)"; |
| presence "Indicates a high node is configured."; | | presence "Indicates a high node is configured."; |
| description | | description |
| "Set metric to highest reachable value"; | | "Set metric to highest reachable value"; |
| } | | } |
| container disabled { | | container disabled { |
| must "not(../maximum or ../high)"; | | must "not(../maximum or ../high)"; |
| presence "Indicates a disabled node is configured."; | | presence "Indicates a disabled node is configured."; |
| description | | description |
| "Ignore reverse-metric requests from neighbors"; | | "Ignore reverse-metric requests from neighbors"; |
| } | | } |
| } | | } |
| } | | } |
| container delay { | | container delay { |
| description | | description |
| "Delay configuration setting"; | | "Delay configuration setting"; |
| container normalize { | | container normalize { |
| description | | description |
| "Delay normalization setting"; | | "Delay normalization setting"; |
| leaf interval { | | leaf interval { |
| type uint32 { | | type uint32 { |
| range "1..16777215" { | | range "1..16777215" { |
| description | | description |
| "Value in microseconds"; | | "Value in microseconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Normalization interval"; | | "Normalization interval"; |
| } | | } |
| leaf offset { | | leaf offset { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Value in microseconds"; | | "Value in microseconds"; |
| } | | } |
| } | | } |
| must "../interval"; | | must "../interval"; |
| description | | description |
| "Normalization offset"; | | "Normalization offset"; |
| } | | } |
| } | | } |
| } | | } |
| container bfd { | | container bfd { |
| description | | description |
| "Configure BFD parameters"; | | "Configure BFD parameters"; |
| container fast-detect { | | container fast-detect { |
| description | | description |
| "Enable Fast detection"; | | "Enable Fast detection"; |
| container ipv4 { | | container ipv4 { |
| presence "Indicates a ipv4 node is configured."; | | presence "Indicates a ipv4 node is configured."; |
| description | | description |
| "Address Family"; | | "Address Family"; |
| } | | } |
| container ipv6 { | | container ipv6 { |
| presence "Indicates a ipv6 node is configured."; | | presence "Indicates a ipv6 node is configured."; |
| description | | description |
| "Address Family"; | | "Address Family"; |
| } | | } |
| } | | } |
| leaf minimum-interval { | | leaf minimum-interval { |
| type uint32 { | | type uint32 { |
| range "3..30000" { | | range "3..30000" { |
| description | | description |
| "hello interval in milli-seconds"; | | "hello interval in milli-seconds"; |
| } | | } |
| } | | } |
| description | | description |
| "Hello interval"; | | "Hello interval"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..50" { | | range "2..50" { |
| description | | description |
| "Detect multiplier"; | | "Detect multiplier"; |
| } | | } |
| } | | } |
| description | | description |
| "Detect multiplier"; | | "Detect multiplier"; |
| } | | } |
| } | | } |
| container passive { | | container passive { |
| must "not(../suppressed or ../shutdown)"; | | must "not(../suppressed or ../shutdown)"; |
| presence "Indicates a passive node is configured."; | | presence "Indicates a passive node is configured."; |
| description | | description |
| "Do not establish adjacencies over this interface"; | | "Do not establish adjacencies over this interface"; |
| } | | } |
| container suppressed { | | container suppressed { |
| must "not(../passive or ../shutdown)"; | | must "not(../passive or ../shutdown)"; |
| presence "Indicates a suppressed node is configured."; | | presence "Indicates a suppressed node is configured."; |
| description | | description |
| "Do not advertise connected prefixes of this interface"; | | "Do not advertise connected prefixes of this interface"; |
| } | | } |
| container shutdown { | | container shutdown { |
| must "not(../passive or ../suppressed)"; | | must "not(../passive or ../suppressed)"; |
| presence "Indicates a shutdown node is configured."; | | presence "Indicates a shutdown node is configured."; |
| description | | description |
| "Shutdown IS-IS on this interface"; | | "Shutdown IS-IS on this interface"; |
| } | | } |
| container mesh-group { | | container mesh-group { |
| description | | description |
| "Set IS-IS mesh group"; | | "Set IS-IS mesh group"; |
| leaf mesh-group-number { | | leaf mesh-group-number { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "Mesh group number"; | | "Mesh group number"; |
| } | | } |
| } | | } |
| description | | description |
| "Mesh group number"; | | "Mesh group number"; |
| } | | } |
| container blocked { | | container blocked { |
| presence "Indicates a blocked node is configured."; | | presence "Indicates a blocked node is configured."; |
| description | | description |
| "Block LSPs on this interface"; | | "Block LSPs on this interface"; |
| } | | } |
| } | | } |
| container address-families { | | container address-families { |
| description | | description |
| "Enter the IS-IS interface address-family configuration submode"; | | "Enter the IS-IS interface address-family configuration submode"; |
| list address-family { | | list address-family { |
| key "af-name saf-name"; | | key "af-name saf-name"; |
| description | | description |
| "Address family"; | | "Address family"; |
| leaf af-name { | | leaf af-name { |
| type Isis-af-name; | | type Isis-af-name; |
| description | | description |
| "Address family name"; | | "Address family name"; |
| } | | } |
| leaf saf-name { | | leaf saf-name { |
| type Isis-saf-name; | | type Isis-saf-name; |
| description | | description |
| "Sub address family name"; | | "Sub address family name"; |
| } | | } |
| container metric { | | container metric { |
| description | | description |
| "Configure the metric for interface"; | | "Configure the metric for interface"; |
| leaf default-metric { | | leaf default-metric { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| must "not(../maximum)"; | | must "not(../maximum)"; |
| description | | description |
| "Default metric"; | | "Default metric"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../default-metric)"; | | must "not(../default-metric)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Maximum wide metric. All routers will exclude this link from their SPF"; | | "Maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set metric at this level only"; | | "Set metric at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| } | | } |
| leaf default-metric { | | leaf default-metric { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| must "not(../maximum)"; | | must "not(../maximum)"; |
| description | | description |
| "Default metric"; | | "Default metric"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../default-metric)"; | | must "not(../default-metric)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Maximum wide metric. All routers will exclude this link from their SPF"; | | "Maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| } | | } |
| container fallback { | | container fallback { |
| description | | description |
| "Configure the metric fallback for interface"; | | "Configure the metric fallback for interface"; |
| container bandwidth { | | container bandwidth { |
| description | | description |
| "fallback based on bandwidth change"; | | "fallback based on bandwidth change"; |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Set Multiplier of interface metric"; | | "Set Multiplier of interface metric"; |
| } | | } |
| } | | } |
| must "../threshold"; | | must "../threshold"; |
| description | | description |
| "fallback based on bandwidth change"; | | "fallback based on bandwidth change"; |
| } | | } |
| leaf threshold { | | leaf threshold { |
| type uint32 { | | type uint32 { |
| range "1..100" { | | range "1..100" { |
| description | | description |
| "Set metric fallback at this threshold only"; | | "Set metric fallback at this threshold only"; |
| } | | } |
| } | | } |
| must "../multiplier"; | | must "../multiplier"; |
| description | | description |
| "Threshold interms of percentage of bandwidth"; | | "Threshold interms of percentage of bandwidth"; |
| } | | } |
| } | | } |
| container anomaly { | | container anomaly { |
| description | | description |
| "Increase the link metric when a delay/loss anomaly occurs"; | | "Increase the link metric when a delay/loss anomaly occurs"; |
| container te-metric { | | container te-metric { |
| description | | description |
| "Modify the TE metric"; | | "Modify the TE metric"; |
| container delay { | | container delay { |
| must | | must |
| "not(../loss or ../increment or ../multiplier | | "not(../loss or ../increment or ../multiplier |
| or ../maximum) and | | or ../maximum) and |
| (increment or multiplier or maximum)"; | | (increment or multiplier or maximum)"; |
| presence "Indicates a delay node is configured."; | | presence "Indicates a delay node is configured."; |
| description | | description |
| "Only increase the link metric when a delay anomaly occurs"; | | "Only increase the link metric when a delay anomaly occurs"; |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must "not(../multiplier or ../maximum)"; | | must "not(../multiplier or ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must "not(../increment or ../maximum)"; | | must "not(../increment or ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../increment or ../multiplier)"; | | must "not(../increment or ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| container loss { | | container loss { |
| must | | must |
| "not(../delay or ../increment or ../multiplier | | "not(../delay or ../increment or ../multiplier |
| or ../maximum) and | | or ../maximum) and |
| (increment or multiplier or maximum)"; | | (increment or multiplier or maximum)"; |
| presence "Indicates a loss node is configured."; | | presence "Indicates a loss node is configured."; |
| description | | description |
| "Only increase the link metric when a loss anomaly occurs"; | | "Only increase the link metric when a loss anomaly occurs"; |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must "not(../multiplier or ../maximum)"; | | must "not(../multiplier or ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must "not(../increment or ../maximum)"; | | must "not(../increment or ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../increment or ../multiplier)"; | | must "not(../increment or ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must | | must |
| "not(../delay or ../loss or ../multiplier or | | "not(../delay or ../loss or ../multiplier or |
| ../maximum)"; | | ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must | | must |
| "not(../delay or ../loss or ../increment or | | "not(../delay or ../loss or ../increment or |
| ../maximum)"; | | ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must | | must |
| "not(../delay or ../loss or ../increment or | | "not(../delay or ../loss or ../increment or |
| ../multiplier)"; | | ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| container te-metric-levels { | | container te-metric-levels { |
| description | | description |
| "Increase metric for one level only"; | | "Increase metric for one level only"; |
| list level { | | list level { |
| must | | must |
| "delay or loss or increment or multiplier | | "delay or loss or increment or multiplier |
| or maximum"; | | or maximum"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set metric at this level only"; | | "Set metric at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| } | | } |
| container delay { | | container delay { |
| must | | must |
| "not(../loss or ../increment or ../multiplier | | "not(../loss or ../increment or ../multiplier |
| or ../maximum) and | | or ../maximum) and |
| (increment or multiplier or maximum)"; | | (increment or multiplier or maximum)"; |
| presence "Indicates a delay node is configured."; | | presence "Indicates a delay node is configured."; |
| description | | description |
| "Only increase the link metric when a delay anomaly occurs"; | | "Only increase the link metric when a delay anomaly occurs"; |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must "not(../multiplier or ../maximum)"; | | must "not(../multiplier or ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must "not(../increment or ../maximum)"; | | must "not(../increment or ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../increment or ../multiplier)"; | | must "not(../increment or ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| container loss { | | container loss { |
| must | | must |
| "not(../delay or ../increment or | | "not(../delay or ../increment or |
| ../multiplier or ../maximum) and | | ../multiplier or ../maximum) and |
| (increment or multiplier or maximum)"; | | (increment or multiplier or maximum)"; |
| presence "Indicates a loss node is configured."; | | presence "Indicates a loss node is configured."; |
| description | | description |
| "Only increase the link metric when a loss anomaly occurs"; | | "Only increase the link metric when a loss anomaly occurs"; |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must "not(../multiplier or ../maximum)"; | | must "not(../multiplier or ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must "not(../increment or ../maximum)"; | | must "not(../increment or ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../increment or ../multiplier)"; | | must "not(../increment or ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must | | must |
| "not(../delay or ../loss or ../multiplier | | "not(../delay or ../loss or ../multiplier |
| or ../maximum)"; | | or ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must | | must |
| "not(../delay or ../loss or ../increment | | "not(../delay or ../loss or ../increment |
| or ../maximum)"; | | or ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must | | must |
| "not(../delay or ../loss or ../increment | | "not(../delay or ../loss or ../increment |
| or ../multiplier)"; | | or ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| } | | } |
| container delay { | | container delay { |
| must | | must |
| "not(../loss or ../increment or ../multiplier | | "not(../loss or ../increment or ../multiplier |
| or ../maximum) and | | or ../maximum) and |
| (increment or multiplier or maximum)"; | | (increment or multiplier or maximum)"; |
| presence "Indicates a delay node is configured."; | | presence "Indicates a delay node is configured."; |
| description | | description |
| "Only increase the link metric when a delay anomaly occurs"; | | "Only increase the link metric when a delay anomaly occurs"; |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must "not(../multiplier or ../maximum)"; | | must "not(../multiplier or ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must "not(../increment or ../maximum)"; | | must "not(../increment or ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../increment or ../multiplier)"; | | must "not(../increment or ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| container loss { | | container loss { |
| must | | must |
| "not(../loss or ../increment or ../multiplier | | "not(../loss or ../increment or ../multiplier |
| or ../maximum) and | | or ../maximum) and |
| (increment or multiplier or maximum)"; | | (increment or multiplier or maximum)"; |
| presence "Indicates a loss node is configured."; | | presence "Indicates a loss node is configured."; |
| description | | description |
| "Only increase the link metric when a loss anomaly occurs"; | | "Only increase the link metric when a loss anomaly occurs"; |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must "not(../multiplier or ../maximum)"; | | must "not(../multiplier or ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must "not(../increment or ../maximum)"; | | must "not(../increment or ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../increment or ../multiplier)"; | | must "not(../increment or ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must | | must |
| "not(../delay or ../loss or ../multiplier | | "not(../delay or ../loss or ../multiplier |
| or ../maximum)"; | | or ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must | | must |
| "not(../delay or ../loss or ../increment | | "not(../delay or ../loss or ../increment |
| or ../maximum)"; | | or ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must | | must |
| "not(../delay or ../loss or ../increment | | "not(../delay or ../loss or ../increment |
| or ../multiplier)"; | | or ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Increase metric for one level only"; | | "Increase metric for one level only"; |
| list level { | | list level { |
| must | | must |
| "delay or loss or increment or multiplier | | "delay or loss or increment or multiplier |
| or maximum"; | | or maximum"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set metric at this level only"; | | "Set metric at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| } | | } |
| container delay { | | container delay { |
| must | | must |
| "not(../loss or ../increment or | | "not(../loss or ../increment or |
| ../multiplier or ../maximum) and | | ../multiplier or ../maximum) and |
| (increment or multiplier or maximum)"; | | (increment or multiplier or maximum)"; |
| presence "Indicates a delay node is configured."; | | presence "Indicates a delay node is configured."; |
| description | | description |
| "Only increase the link metric when a delay anomaly occurs"; | | "Only increase the link metric when a delay anomaly occurs"; |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must "not(../multiplier or ../maximum)"; | | must "not(../multiplier or ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must "not(../increment or ../maximum)"; | | must "not(../increment or ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../increment or ../multiplier)"; | | must "not(../increment or ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| container loss { | | container loss { |
| must | | must |
| "not(../delay or ../increment or | | "not(../delay or ../increment or |
| ../multiplier or ../maximum) and | | ../multiplier or ../maximum) and |
| (increment or multiplier or maximum)"; | | (increment or multiplier or maximum)"; |
| presence "Indicates a loss node is configured."; | | presence "Indicates a loss node is configured."; |
| description | | description |
| "Only increase the link metric when a loss anomaly occurs"; | | "Only increase the link metric when a loss anomaly occurs"; |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must "not(../multiplier or ../maximum)"; | | must "not(../multiplier or ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must "not(../increment or ../maximum)"; | | must "not(../increment or ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../increment or ../multiplier)"; | | must "not(../increment or ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| leaf increment { | | leaf increment { |
| type uint32 { | | type uint32 { |
| range "1..16777213" { | | range "1..16777213" { |
| description | | description |
| "Metric increment"; | | "Metric increment"; |
| } | | } |
| } | | } |
| must | | must |
| "not(../delay or ../loss or ../multiplier | | "not(../delay or ../loss or ../multiplier |
| or ../maximum)"; | | or ../maximum)"; |
| description | | description |
| "Increment the link metric by the following amount"; | | "Increment the link metric by the following amount"; |
| } | | } |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Metric multiplier"; | | "Metric multiplier"; |
| } | | } |
| } | | } |
| must | | must |
| "not(../delay or ../loss or ../increment | | "not(../delay or ../loss or ../increment |
| or ../maximum)"; | | or ../maximum)"; |
| description | | description |
| "Multiply the link metric by the following amount"; | | "Multiply the link metric by the following amount"; |
| } | | } |
| container maximum { | | container maximum { |
| must | | must |
| "not(../delay or ../loss or ../increment | | "not(../delay or ../loss or ../increment |
| or ../multiplier)"; | | or ../multiplier)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Set the maximum wide metric. All routers will exclude this link from their SPF"; | | "Set the maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container te-metric { | | container te-metric { |
| description | | description |
| "Configure an application specific TE metric for the interface"; | | "Configure an application specific TE metric for the interface"; |
| leaf flex-algo { | | leaf flex-algo { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Flex-algo traffic-engineering metric"; | | "Flex-algo traffic-engineering metric"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure a Flex-algo TE metric for the interface"; | | "Configure a Flex-algo TE metric for the interface"; |
| } | | } |
| } | | } |
| container te-metric-levels { | | container te-metric-levels { |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set metric at this level only"; | | "Set metric at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| } | | } |
| leaf flex-algo { | | leaf flex-algo { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Flex-algo traffic-engineering metric"; | | "Flex-algo traffic-engineering metric"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Configure a Flex-algo TE metric for the interface"; | | "Configure a Flex-algo TE metric for the interface"; |
| } | | } |
| } | | } |
| } | | } |
| n | container generic-metric { | n | |
| description | | |
| "Configure an application specific generic metric for the interface"; | | |
| list metric-type { | | |
| key "metric-type"; | | |
| description | | |
| "Set metric for one metric-type"; | | |
| leaf metric-type { | | |
| type uint32 { | | |
| range "128..255" { | | |
| description | | |
| "Set Genric-metric Type"; | | |
| } | | |
| } | | |
| description | | |
| "Set metric for one level only"; | | |
| } | | |
| leaf flex-algo { | | |
| type uint32 { | | |
| range "1..16777214" { | | |
| description | | |
| "Flex-algo traffic-engineering metric"; | | |
| } | | |
| } | | |
| description | | |
| "Configure a Flex-algo Generic metric for the interface"; | | |
| } | | |
| } | | |
| } | | |
| container generic-metric-levels { | | |
| description | | |
| "Configure an application specific generic metric for the interface"; | | |
| list level-metric-type { | | |
| key "level-id metric-type"; | | |
| description | | |
| "Set metric for one metric-type"; | | |
| leaf level-id { | | |
| type uint32 { | | |
| range "1..2" { | | |
| description | | |
| "Set metric at this level only"; | | |
| } | | |
| } | | |
| description | | |
| "Set metric for one level only"; | | |
| } | | |
| leaf metric-type { | | |
| type uint32 { | | |
| range "128..255" { | | |
| description | | |
| "Set Genric-metric Type"; | | |
| } | | |
| } | | |
| description | | |
| "Set metric for one level only"; | | |
| } | | |
| leaf flex-algo { | | |
| type uint32 { | | |
| range "1..16777214" { | | |
| description | | |
| "Flex-algo traffic-engineering metric"; | | |
| } | | |
| } | | |
| description | | |
| "Configure a Flex-algo Generic metric for the interface"; | | |
| } | | |
| } | | |
| } | | |
| container mpls { | | container mpls { |
| when "../saf-name = 'unicast'"; | | when "../saf-name = 'unicast'"; |
| description | | description |
| "Configure MPLS routing protocol parameters"; | | "Configure MPLS routing protocol parameters"; |
| container ldp { | | container ldp { |
| description | | description |
| "Configure LDP parameters"; | | "Configure LDP parameters"; |
| container sync { | | container sync { |
| presence "Indicates a sync node is configured."; | | presence "Indicates a sync node is configured."; |
| description | | description |
| "Configure LDP ISIS synchronization"; | | "Configure LDP ISIS synchronization"; |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set LDP synchronization at this level only"; | | "Set LDP synchronization at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set LDP synchronization for one level only"; | | "Set LDP synchronization for one level only"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container tag { | | container tag { |
| description | | description |
| "Set interface tag"; | | "Set interface tag"; |
| leaf interface-tag { | | leaf interface-tag { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "Interface tag"; | | "Interface tag"; |
| } | | } |
| } | | } |
| description | | description |
| "Set interface tag"; | | "Set interface tag"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set the tag only at supplied level"; | | "Set the tag only at supplied level"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set the tag only at supplied level"; | | "Set the tag only at supplied level"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set the tag only at this level"; | | "Set the tag only at this level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set the tag only at supplied level"; | | "Set the tag only at supplied level"; |
| } | | } |
| leaf interface-tag { | | leaf interface-tag { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "Interface tag"; | | "Interface tag"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set interface tag"; | | "Set interface tag"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container prefix-sid { | | container prefix-sid { |
| when "../saf-name = 'unicast' and ../../../interface-name[starts-with(text(),'Loopback')]" { | | when "../saf-name = 'unicast' and ../../../interface-name[starts-with(text(),'Loopback')]" { |
| tailf:dependency "../../../interface-name"; | | tailf:dependency "../../../interface-name"; |
| } | | } |
| n | description | n | |
| "Specify the Prefix Segment ID"; | | |
| container sid { | | container sid { |
| must "index or absolute"; | | must "index or absolute"; |
| presence "Indicates a sid node is configured."; | | presence "Indicates a sid node is configured."; |
| description | | description |
| "Specify the Prefix Segment ID"; | | "Specify the Prefix Segment ID"; |
| container index { | | container index { |
| must "not(../absolute)"; | | must "not(../absolute)"; |
| presence "Indicates a index node is configured."; | | presence "Indicates a index node is configured."; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| leaf sid-index { | | leaf sid-index { |
| type uint32 { | | type uint32 { |
| range "0..1048575" { | | range "0..1048575" { |
| description | | description |
| "The Prefix Segment ID index"; | | "The Prefix Segment ID index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| } | | } |
| } | | } |
| container absolute { | | container absolute { |
| must "not(../index)"; | | must "not(../index)"; |
| presence "Indicates a absolute node is configured."; | | presence "Indicates a absolute node is configured."; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| leaf sid-value { | | leaf sid-value { |
| type uint32 { | | type uint32 { |
| range "16000..1048575" { | | range "16000..1048575" { |
| description | | description |
| "The Prefix Segment ID value"; | | "The Prefix Segment ID value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| } | | } |
| } | | } |
| n | container php-disable { | n | |
| presence "Indicates a php-disable node is configured."; | | |
| description | | |
| "Disable Penultimate Hop Popping"; | | |
| } | | |
| container explicit-null { | | container explicit-null { |
| presence "Indicates a explicit-null node is configured."; | | presence "Indicates a explicit-null node is configured."; |
| description | | description |
| "Upstream neighbor must replace prefix-sid with explicit null label"; | | "Upstream neighbor must replace prefix-sid with explicit null label"; |
| } | | } |
| container n-flag-clear { | | container n-flag-clear { |
| presence "Indicates a n-flag-clear node is configured."; | | presence "Indicates a n-flag-clear node is configured."; |
| description | | description |
| "Clear N-flag for the prefix-SID "; | | "Clear N-flag for the prefix-SID "; |
| } | | } |
| } | | } |
| container strict-spf { | | container strict-spf { |
| must "index or absolute"; | | must "index or absolute"; |
| presence "Indicates a strict-spf node is configured."; | | presence "Indicates a strict-spf node is configured."; |
| description | | description |
| "Strict-SPF Prefix SID Configuration"; | | "Strict-SPF Prefix SID Configuration"; |
| container index { | | container index { |
| must "not(../absolute)"; | | must "not(../absolute)"; |
| presence "Indicates a index node is configured."; | | presence "Indicates a index node is configured."; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| leaf sid-index { | | leaf sid-index { |
| type uint32 { | | type uint32 { |
| range "0..1048575" { | | range "0..1048575" { |
| description | | description |
| "The Prefix Segment ID index"; | | "The Prefix Segment ID index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| } | | } |
| } | | } |
| container absolute { | | container absolute { |
| must "not(../index)"; | | must "not(../index)"; |
| presence "Indicates a absolute node is configured."; | | presence "Indicates a absolute node is configured."; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| leaf sid-value { | | leaf sid-value { |
| type uint32 { | | type uint32 { |
| range "16000..1048575" { | | range "16000..1048575" { |
| description | | description |
| "The Prefix Segment ID value"; | | "The Prefix Segment ID value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| } | | } |
| n | } | n | |
| container php-disable { | | |
| presence "Indicates a php-disable node is configured."; | | |
| description | | |
| "Disable Penultimate Hop Popping"; | | |
| } | | } |
| container explicit-null { | | container explicit-null { |
| presence "Indicates a explicit-null node is configured."; | | presence "Indicates a explicit-null node is configured."; |
| description | | description |
| "Upstream neighbor must replace prefix-sid with explicit null label"; | | "Upstream neighbor must replace prefix-sid with explicit null label"; |
| } | | } |
| container n-flag-clear { | | container n-flag-clear { |
| presence "Indicates a n-flag-clear node is configured."; | | presence "Indicates a n-flag-clear node is configured."; |
| description | | description |
| "Clear N-flag for the prefix-SID "; | | "Clear N-flag for the prefix-SID "; |
| } | | } |
| } | | } |
| container algorithms { | | container algorithms { |
| description | | description |
| "Algorithm Specific Prefix SID Configuration"; | | "Algorithm Specific Prefix SID Configuration"; |
| list algorithm { | | list algorithm { |
| key "algorithm-number"; | | key "algorithm-number"; |
| description | | description |
| "Algorithm Specific Prefix SID Configuration"; | | "Algorithm Specific Prefix SID Configuration"; |
| leaf algorithm-number { | | leaf algorithm-number { |
| type uint32 { | | type uint32 { |
| range "128..255" { | | range "128..255" { |
| description | | description |
| "Algorithm number"; | | "Algorithm number"; |
| } | | } |
| } | | } |
| description | | description |
| "Algorithm Specific Prefix SID Configuration"; | | "Algorithm Specific Prefix SID Configuration"; |
| } | | } |
| container index { | | container index { |
| must "not(../absolute)"; | | must "not(../absolute)"; |
| presence "Indicates a index node is configured."; | | presence "Indicates a index node is configured."; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| leaf sid-index { | | leaf sid-index { |
| type uint32 { | | type uint32 { |
| range "0..1048575" { | | range "0..1048575" { |
| description | | description |
| "The Prefix Segment ID index"; | | "The Prefix Segment ID index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the index of Prefix Segement ID"; | | "Specify the index of Prefix Segement ID"; |
| } | | } |
| } | | } |
| container absolute { | | container absolute { |
| must "not(../index)"; | | must "not(../index)"; |
| presence "Indicates a absolute node is configured."; | | presence "Indicates a absolute node is configured."; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| leaf sid-value { | | leaf sid-value { |
| type uint32 { | | type uint32 { |
| range "16000..1048575" { | | range "16000..1048575" { |
| description | | description |
| "The Prefix Segment ID value"; | | "The Prefix Segment ID value"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Specify the absolute value of Prefix Segement ID"; | | "Specify the absolute value of Prefix Segement ID"; |
| } | | } |
| } | | } |
| n | container php-disable { | n | |
| presence "Indicates a php-disable node is configured."; | | |
| description | | |
| "Disable Penultimate Hop Popping"; | | |
| } | | |
| container explicit-null { | | container explicit-null { |
| presence "Indicates a explicit-null node is configured."; | | presence "Indicates a explicit-null node is configured."; |
| description | | description |
| "Upstream neighbor must replace prefix-sid with explicit null label"; | | "Upstream neighbor must replace prefix-sid with explicit null label"; |
| } | | } |
| container n-flag-clear { | | container n-flag-clear { |
| presence "Indicates a n-flag-clear node is configured."; | | presence "Indicates a n-flag-clear node is configured."; |
| description | | description |
| "Clear N-flag for the prefix-SID "; | | "Clear N-flag for the prefix-SID "; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container adjacency-sid { | | container adjacency-sid { |
| when "../saf-name = 'unicast'"; | | when "../saf-name = 'unicast'"; |
| description | | description |
| "Specify the Adjacency Segment ID"; | | "Specify the Adjacency Segment ID"; |
| container indexes { | | container indexes { |
| description | | description |
| "Specify the index of Adjacency Segement ID"; | | "Specify the index of Adjacency Segement ID"; |
| list index { | | list index { |
| key "sid-index"; | | key "sid-index"; |
| description | | description |
| "Specify the index of Adjacency Segement ID"; | | "Specify the index of Adjacency Segement ID"; |
| leaf sid-index { | | leaf sid-index { |
| type uint32 { | | type uint32 { |
| range "0..1048575" { | | range "0..1048575" { |
| description | | description |
| "The Adjacency Segment ID index"; | | "The Adjacency Segment ID index"; |
| } | | } |
| } | | } |
| description | | description |
| "Specify the index of Adjacency Segement ID"; | | "Specify the index of Adjacency Segement ID"; |
| } | | } |
| container protected { | | container protected { |
| presence "Indicates a protected node is configured."; | | presence "Indicates a protected node is configured."; |
| description | | description |
| "Protect Adjacency SID"; | | "Protect Adjacency SID"; |
| } | | } |
| } | | } |
| } | | } |
| container absolutes { | | container absolutes { |
| description | | description |
| "Specify the absolute value of Adjacency Segement ID"; | | "Specify the absolute value of Adjacency Segement ID"; |
| list absolute { | | list absolute { |
| key "sid-value"; | | key "sid-value"; |
| description | | description |
| "Specify the absolute value of Adjacency Segement ID"; | | "Specify the absolute value of Adjacency Segement ID"; |
| leaf sid-value { | | leaf sid-value { |
| type uint32 { | | type uint32 { |
| range "0..1048575" { | | range "0..1048575" { |
| description | | description |
| "The Adjacency Segment ID value"; | | "The Adjacency Segment ID value"; |
| } | | } |
| } | | } |
| description | | description |
| "Specify the absolute value of Adjacency Segement ID"; | | "Specify the absolute value of Adjacency Segement ID"; |
| } | | } |
| container protected { | | container protected { |
| presence "Indicates a protected node is configured."; | | presence "Indicates a protected node is configured."; |
| description | | description |
| "Protect Adjacency SID"; | | "Protect Adjacency SID"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container fast-reroute { | | container fast-reroute { |
| when "../saf-name = 'unicast'"; | | when "../saf-name = 'unicast'"; |
| description | | description |
| "Configure Fast ReRoute"; | | "Configure Fast ReRoute"; |
| container computation { | | container computation { |
| n | description | n | |
| "Computation Fast ReRoute"; | | |
| container per-link-computation { | | container per-link-computation { |
| must "not(../per-prefix-computation)"; | | must "not(../per-prefix-computation)"; |
| presence "Indicates a per-link-computation node is configured."; | | presence "Indicates a per-link-computation node is configured."; |
| description | | description |
| "Prefix independent per-link computation"; | | "Prefix independent per-link computation"; |
| } | | } |
| container per-prefix-computation { | | container per-prefix-computation { |
| must "not(../per-link-computation)"; | | must "not(../per-link-computation)"; |
| presence "Indicates a per-prefix-computation node is configured."; | | presence "Indicates a per-prefix-computation node is configured."; |
| description | | description |
| "Prefix dependent computation"; | | "Prefix dependent computation"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure FRR for one level only"; | | "Configure FRR for one level only"; |
| list level { | | list level { |
| must "per-link-computation or per-prefix-computation"; | | must "per-link-computation or per-prefix-computation"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure FRR for one level only"; | | "Configure FRR for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure FRR for one level only"; | | "Configure FRR for one level only"; |
| } | | } |
| container per-link-computation { | | container per-link-computation { |
| must "not(../per-prefix-computation)"; | | must "not(../per-prefix-computation)"; |
| presence "Indicates a per-link node is configured."; | | presence "Indicates a per-link node is configured."; |
| description | | description |
| "Prefix independent per-link computation"; | | "Prefix independent per-link computation"; |
| } | | } |
| container per-prefix-computation { | | container per-prefix-computation { |
| must "not(../per-link-computation)"; | | must "not(../per-link-computation)"; |
| presence "Indicates a per-prefix node is configured."; | | presence "Indicates a per-prefix node is configured."; |
| description | | description |
| "Prefix dependent computation"; | | "Prefix dependent computation"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container per-link { | | container per-link { |
| description | | description |
| "Prefix independent per-link computation"; | | "Prefix independent per-link computation"; |
| container exclude { | | container exclude { |
| description | | description |
| "FRR exclusion information"; | | "FRR exclusion information"; |
| container interfaces { | | container interfaces { |
| description | | description |
| "Exclude an interface from computation"; | | "Exclude an interface from computation"; |
| list interface { | | list interface { |
| key "interface-name"; | | key "interface-name"; |
| description | | description |
| "Exclude an interface from computation"; | | "Exclude an interface from computation"; |
| leaf interface-name { | | leaf interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Exclude an interface from computation"; | | "Exclude an interface from computation"; |
| } | | } |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Exclude interface for one level only"; | | "Exclude interface for one level only"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container lfa-candidate { | | container lfa-candidate { |
| description | | description |
| "FRR LFA candidate information"; | | "FRR LFA candidate information"; |
| container interfaces { | | container interfaces { |
| description | | description |
| "Include an interface to LFA candidate in computation"; | | "Include an interface to LFA candidate in computation"; |
| list interface { | | list interface { |
| key "interface-name"; | | key "interface-name"; |
| description | | description |
| "Include an interface to LFA candidate in computation"; | | "Include an interface to LFA candidate in computation"; |
| leaf interface-name { | | leaf interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Include an interface to LFA candidate in computation"; | | "Include an interface to LFA candidate in computation"; |
| } | | } |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Include interface for one level only"; | | "Include interface for one level only"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container per-prefix { | | container per-prefix { |
| description | | description |
| "Prefix dependent computation"; | | "Prefix dependent computation"; |
| container remote-lfa { | | container remote-lfa { |
| description | | description |
| "Enable remote LFA computation"; | | "Enable remote LFA computation"; |
| container tunnel { | | container tunnel { |
| description | | description |
| "Enable remote LFA computation using tunnels"; | | "Enable remote LFA computation using tunnels"; |
| container mpls-ldp { | | container mpls-ldp { |
| presence "Indicates a mpls-ldp node is configured."; | | presence "Indicates a mpls-ldp node is configured."; |
| description | | description |
| "Use MPLS LDP tunnel to reach the remote LFA node"; | | "Use MPLS LDP tunnel to reach the remote LFA node"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Enable remote LFA for one level only"; | | "Enable remote LFA for one level only"; |
| list level { | | list level { |
| must "mpls-ldp"; | | must "mpls-ldp"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Enable remote LFA for one level only"; | | "Enable remote LFA for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set remote LFA for this level"; | | "Set remote LFA for this level"; |
| } | | } |
| } | | } |
| description | | description |
| "Enable remote LFA for one level only"; | | "Enable remote LFA for one level only"; |
| } | | } |
| container mpls-ldp { | | container mpls-ldp { |
| presence "Indicates a mpls-ldp node is configured."; | | presence "Indicates a mpls-ldp node is configured."; |
| description | | description |
| "Use MPLS LDP tunnel to reach the remote LFA node"; | | "Use MPLS LDP tunnel to reach the remote LFA node"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container maximum-metric { | | container maximum-metric { |
| description | | description |
| "Limit remote LFA node selection within the metric"; | | "Limit remote LFA node selection within the metric"; |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "1..16777215" { | | range "1..16777215" { |
| description | | description |
| "Value of the metric"; | | "Value of the metric"; |
| } | | } |
| } | | } |
| description | | description |
| "Value of the metric"; | | "Value of the metric"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Enable remote LFA max metric for one level only"; | | "Enable remote LFA max metric for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Enable remote LFA max metric for one level only"; | | "Enable remote LFA max metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set remote LFA max metric value for this level"; | | "Set remote LFA max metric value for this level"; |
| } | | } |
| } | | } |
| description | | description |
| "Enable remote LFA max metric for one level only"; | | "Enable remote LFA max metric for one level only"; |
| } | | } |
| leaf metric { | | leaf metric { |
| type uint32 { | | type uint32 { |
| range "1..16777215" { | | range "1..16777215" { |
| description | | description |
| "Value of the metric"; | | "Value of the metric"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Value of the metric"; | | "Value of the metric"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container per-prefix { | | container per-prefix { |
| description | | description |
| "Prefix dependent computation"; | | "Prefix dependent computation"; |
| container ti-lfa { | | container ti-lfa { |
| presence "Indicates a ti-lfa node is configured."; | | presence "Indicates a ti-lfa node is configured."; |
| description | | description |
| "Enable TI LFA computation"; | | "Enable TI LFA computation"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Enable EPCFRR LFA for one level only"; | | "Enable EPCFRR LFA for one level only"; |
| list level { | | list level { |
| must "ti-lfa"; | | must "ti-lfa"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Enable EPCFRR LFA for one level only"; | | "Enable EPCFRR LFA for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set EPCFRR LFA for this level"; | | "Set EPCFRR LFA for this level"; |
| } | | } |
| } | | } |
| description | | description |
| "Enable EPCFRR LFA for one level only"; | | "Enable EPCFRR LFA for one level only"; |
| } | | } |
| container ti-lfa { | | container ti-lfa { |
| presence "Indicates a ti-lfa node is configured."; | | presence "Indicates a ti-lfa node is configured."; |
| description | | description |
| "Enable TI LFA computation"; | | "Enable TI LFA computation"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container tiebreaker { | | container tiebreaker { |
| description | | description |
| "Configure tiebreaker for multiple backups"; | | "Configure tiebreaker for multiple backups"; |
| container node-protecting { | | container node-protecting { |
| description | | description |
| "Prefer node protecting backup path"; | | "Prefer node protecting backup path"; |
| container index { | | container index { |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| leaf preference-order { | | leaf preference-order { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| } | | } |
| leaf preference-order { | | leaf preference-order { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container srlg-disjoint { | | container srlg-disjoint { |
| description | | description |
| "Prefer SRLG disjoint backup path"; | | "Prefer SRLG disjoint backup path"; |
| container index { | | container index { |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| leaf preference-order { | | leaf preference-order { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| } | | } |
| leaf preference-order { | | leaf preference-order { |
| type uint32 { | | type uint32 { |
| range "1..255" { | | range "1..255" { |
| description | | description |
| "Index"; | | "Index"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set preference order among tiebreakers"; | | "Set preference order among tiebreakers"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container default { | | container default { |
| description | | description |
| "Prefer default (link protecting) backup path"; | | "Prefer default (link protecting) backup path"; |
| container default-backup-path { | | container default-backup-path { |
| presence "Indicates a default node is configured."; | | presence "Indicates a default node is configured."; |
| description | | description |
| "Prefer default (link protecting) backup path"; | | "Prefer default (link protecting) backup path"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| list level { | | list level { |
| must "default-backup-path"; | | must "default-backup-path"; |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure tiebreaker for one level only"; | | "Configure tiebreaker for one level only"; |
| } | | } |
| container default-backup-path { | | container default-backup-path { |
| presence "Indicates a default node is configured."; | | presence "Indicates a default node is configured."; |
| description | | description |
| "Prefer default (link protecting) backup path"; | | "Prefer default (link protecting) backup path"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container exclude { | | container exclude { |
| description | | description |
| "FRR exclusion information"; | | "FRR exclusion information"; |
| container interfaces { | | container interfaces { |
| description | | description |
| "Exclude an interface from computation"; | | "Exclude an interface from computation"; |
| list interface { | | list interface { |
| key "interface-name"; | | key "interface-name"; |
| description | | description |
| "Exclude an interface from computation"; | | "Exclude an interface from computation"; |
| leaf interface-name { | | leaf interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Exclude an interface from computation"; | | "Exclude an interface from computation"; |
| } | | } |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Exclude interface for one level only"; | | "Exclude interface for one level only"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container lfa-candidate { | | container lfa-candidate { |
| description | | description |
| "FRR LFA candidate information"; | | "FRR LFA candidate information"; |
| container interfaces { | | container interfaces { |
| description | | description |
| "Include an interface to LFA candidate in computation"; | | "Include an interface to LFA candidate in computation"; |
| list interface { | | list interface { |
| key "interface-name"; | | key "interface-name"; |
| description | | description |
| "Include an interface to LFA candidate in computation"; | | "Include an interface to LFA candidate in computation"; |
| leaf interface-name { | | leaf interface-name { |
| type xr:Interface-name; | | type xr:Interface-name; |
| description | | description |
| "Include an interface to LFA candidate in computation"; | | "Include an interface to LFA candidate in computation"; |
| } | | } |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Include interface for one level only"; | | "Include interface for one level only"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container link-group { | | container link-group { |
| presence "Indicates a link-group node is configured."; | | presence "Indicates a link-group node is configured."; |
| description | | description |
| "Set interface link group"; | | "Set interface link group"; |
| leaf link-group-name { | | leaf link-group-name { |
| type string { | | type string { |
| length "1..40" { | | length "1..40" { |
| description | | description |
| "Interface link group"; | | "Interface link group"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set interface link group"; | | "Set interface link group"; |
| } | | } |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set the tag only at this level"; | | "Set the tag only at this level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set the tag only at supplied level"; | | "Set the tag only at supplied level"; |
| } | | } |
| } | | } |
| container weight { | | container weight { |
| description | | description |
| "Configure weight for the interface"; | | "Configure weight for the interface"; |
| leaf weight-value { | | leaf weight-value { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Configure weight for unequal load balancing"; | | "Configure weight for unequal load balancing"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure weight for the interface"; | | "Configure weight for the interface"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set weight for one level only"; | | "Set weight for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set weight for one level only"; | | "Set weight for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set weight at this level only"; | | "Set weight at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set weight for one level only"; | | "Set weight for one level only"; |
| } | | } |
| leaf weight-value { | | leaf weight-value { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Configure weight for unequal load balancing"; | | "Configure weight for unequal load balancing"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Configure weight for the interface"; | | "Configure weight for the interface"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container auto-metric { | | container auto-metric { |
| description | | description |
| "Configure the auto-metric for interface"; | | "Configure the auto-metric for interface"; |
| container proactive-protect { | | container proactive-protect { |
| description | | description |
| "set auto-metric proactive-protect mode"; | | "set auto-metric proactive-protect mode"; |
| leaf absolute-metric { | | leaf absolute-metric { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; | | "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; | | "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set metric at this level only"; | | "Set metric at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| } | | } |
| leaf absolute-metric { | | leaf absolute-metric { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; | | "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; | | "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container advertise { | | container advertise { |
| when "../saf-name = 'unicast'"; | | when "../saf-name = 'unicast'"; |
| description | | description |
| "Configure the AF specific advertisement"; | | "Configure the AF specific advertisement"; |
| container prefix { | | container prefix { |
| description | | description |
| "Configure the prefix advertisement"; | | "Configure the prefix advertisement"; |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Filter routes based on a route policy"; | | "Filter routes based on a route policy"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set advertisement for one level only"; | | "Set advertisement for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set advertisement for one level only"; | | "Set advertisement for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set advertisement at this level only"; | | "Set advertisement at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set advertisement for one level only"; | | "Set advertisement for one level only"; |
| } | | } |
| leaf route-policy { | | leaf route-policy { |
| type xr:Route-policy-name; | | type xr:Route-policy-name; |
| description | | description |
| "Filter routes based on a route policy"; | | "Filter routes based on a route policy"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container disable { | | container disable { |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable IS-IS for this topology on this interface"; | | "Disable IS-IS for this topology on this interface"; |
| } | | } |
| } | | } |
| list address-family-topology { | | list address-family-topology { |
| key "af-name saf-name topology-name"; | | key "af-name saf-name topology-name"; |
| description | | description |
| "Address family with a non-default topology"; | | "Address family with a non-default topology"; |
| leaf af-name { | | leaf af-name { |
| type Isis-af-name; | | type Isis-af-name; |
| description | | description |
| "Address family name"; | | "Address family name"; |
| } | | } |
| leaf saf-name { | | leaf saf-name { |
| type Isis-saf-name; | | type Isis-saf-name; |
| description | | description |
| "Sub address family name"; | | "Sub address family name"; |
| } | | } |
| leaf topology-name { | | leaf topology-name { |
| type string { | | type string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Topology name"; | | "Topology name"; |
| } | | } |
| } | | } |
| description | | description |
| "Specify a non-default topology"; | | "Specify a non-default topology"; |
| } | | } |
| container metric { | | container metric { |
| description | | description |
| "Configure the metric for interface"; | | "Configure the metric for interface"; |
| leaf default-metric { | | leaf default-metric { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| must "not(../maximum)"; | | must "not(../maximum)"; |
| description | | description |
| "Default metric"; | | "Default metric"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../default-metric)"; | | must "not(../default-metric)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Maximum wide metric. All routers will exclude this link from their SPF"; | | "Maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set metric at this level only"; | | "Set metric at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| } | | } |
| leaf default-metric { | | leaf default-metric { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Default metric: <1-63> for narrow, <1-16777214> for wide"; | | "Default metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| must "not(../maximum)"; | | must "not(../maximum)"; |
| description | | description |
| "Default metric"; | | "Default metric"; |
| } | | } |
| container maximum { | | container maximum { |
| must "not(../default-metric)"; | | must "not(../default-metric)"; |
| presence "Indicates a maximum node is configured."; | | presence "Indicates a maximum node is configured."; |
| description | | description |
| "Maximum wide metric. All routers will exclude this link from their SPF"; | | "Maximum wide metric. All routers will exclude this link from their SPF"; |
| } | | } |
| } | | } |
| } | | } |
| container fallback { | | container fallback { |
| description | | description |
| "Configure the metric fallback for interface"; | | "Configure the metric fallback for interface"; |
| container bandwidth { | | container bandwidth { |
| description | | description |
| "fallback based on bandwidth change"; | | "fallback based on bandwidth change"; |
| leaf multiplier { | | leaf multiplier { |
| type uint32 { | | type uint32 { |
| range "2..100000" { | | range "2..100000" { |
| description | | description |
| "Set Multiplier of interface metric"; | | "Set Multiplier of interface metric"; |
| } | | } |
| } | | } |
| must "../threshold"; | | must "../threshold"; |
| description | | description |
| "fallback based on bandwidth change"; | | "fallback based on bandwidth change"; |
| } | | } |
| leaf threshold { | | leaf threshold { |
| type uint32 { | | type uint32 { |
| range "1..100" { | | range "1..100" { |
| description | | description |
| "Set metric fallback at this threshold only"; | | "Set metric fallback at this threshold only"; |
| } | | } |
| } | | } |
| must "../multiplier"; | | must "../multiplier"; |
| description | | description |
| "Threshold interms of percentage of bandwidth"; | | "Threshold interms of percentage of bandwidth"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container te-metric { | | container te-metric { |
| description | | description |
| "Configure an application specific TE metric for the interface"; | | "Configure an application specific TE metric for the interface"; |
| leaf flex-algo { | | leaf flex-algo { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Flex-algo traffic-engineering metric"; | | "Flex-algo traffic-engineering metric"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure a Flex-algo TE metric for the interface"; | | "Configure a Flex-algo TE metric for the interface"; |
| } | | } |
| } | | } |
| container te-metric-levels { | | container te-metric-levels { |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set metric at this level only"; | | "Set metric at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| } | | } |
| leaf flex-algo { | | leaf flex-algo { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Flex-algo traffic-engineering metric"; | | "Flex-algo traffic-engineering metric"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Configure a Flex-algo TE metric for the interface"; | | "Configure a Flex-algo TE metric for the interface"; |
| } | | } |
| } | | } |
| } | | } |
| container tag { | | container tag { |
| description | | description |
| "Set interface tag"; | | "Set interface tag"; |
| leaf interface-tag { | | leaf interface-tag { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "Interface tag"; | | "Interface tag"; |
| } | | } |
| } | | } |
| description | | description |
| "Set interface tag"; | | "Set interface tag"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set the tag only at supplied level"; | | "Set the tag only at supplied level"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set the tag only at supplied level"; | | "Set the tag only at supplied level"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set the tag only at this level"; | | "Set the tag only at this level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set the tag only at supplied level"; | | "Set the tag only at supplied level"; |
| } | | } |
| leaf interface-tag { | | leaf interface-tag { |
| type uint32 { | | type uint32 { |
| range "1..4294967295" { | | range "1..4294967295" { |
| description | | description |
| "Interface tag"; | | "Interface tag"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set interface tag"; | | "Set interface tag"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container link-group { | | container link-group { |
| presence "Indicates a link-group node is configured."; | | presence "Indicates a link-group node is configured."; |
| description | | description |
| "Set interface link group"; | | "Set interface link group"; |
| leaf link-group-name { | | leaf link-group-name { |
| type string { | | type string { |
| length "1..40" { | | length "1..40" { |
| description | | description |
| "Interface link group"; | | "Interface link group"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Set interface link group"; | | "Set interface link group"; |
| } | | } |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set the tag only at this level"; | | "Set the tag only at this level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set the tag only at supplied level"; | | "Set the tag only at supplied level"; |
| } | | } |
| } | | } |
| container weight { | | container weight { |
| description | | description |
| "Configure weight for the interface"; | | "Configure weight for the interface"; |
| leaf weight-value { | | leaf weight-value { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Configure weight for unequal load balancing"; | | "Configure weight for unequal load balancing"; |
| } | | } |
| } | | } |
| description | | description |
| "Configure weight for the interface"; | | "Configure weight for the interface"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set weight for one level only"; | | "Set weight for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set weight for one level only"; | | "Set weight for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set weight at this level only"; | | "Set weight at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set weight for one level only"; | | "Set weight for one level only"; |
| } | | } |
| leaf weight-value { | | leaf weight-value { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Configure weight for unequal load balancing"; | | "Configure weight for unequal load balancing"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Configure weight for the interface"; | | "Configure weight for the interface"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container auto-metric { | | container auto-metric { |
| description | | description |
| "Configure the auto-metric for interface"; | | "Configure the auto-metric for interface"; |
| container proactive-protect { | | container proactive-protect { |
| description | | description |
| "set auto-metric proactive-protect mode"; | | "set auto-metric proactive-protect mode"; |
| leaf absolute-metric { | | leaf absolute-metric { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; | | "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| description | | description |
| "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; | | "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| container levels { | | container levels { |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| list level { | | list level { |
| key "level-id"; | | key "level-id"; |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| leaf level-id { | | leaf level-id { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Set metric at this level only"; | | "Set metric at this level only"; |
| } | | } |
| } | | } |
| description | | description |
| "Set metric for one level only"; | | "Set metric for one level only"; |
| } | | } |
| leaf absolute-metric { | | leaf absolute-metric { |
| type uint32 { | | type uint32 { |
| range "1..16777214" { | | range "1..16777214" { |
| description | | description |
| "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; | | "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; | | "Absolute metric: <1-63> for narrow, <1-16777214> for wide"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container disable { | | container disable { |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable IS-IS for this topology on this interface"; | | "Disable IS-IS for this topology on this interface"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container distribute { | | container distribute { |
| description | | description |
| "Distribute routing information to external services"; | | "Distribute routing information to external services"; |
| container link-state { | | container link-state { |
| n | presence "Indicates a link-state node is configured."; | n | presence "Indicates a link-state node is configured"; |
| description | | description |
| "Distribute the link-state database to external services"; | | "Distribute the link-state database to external services"; |
| leaf instance-id { | | leaf instance-id { |
| type uint32 { | | type uint32 { |
| range "32..4294967295" { | | range "32..4294967295" { |
| description | | description |
| "Instance ID"; | | "Instance ID"; |
| } | | } |
| } | | } |
| description | | description |
| "Set distribution process instance identifier"; | | "Set distribution process instance identifier"; |
| } | | } |
| n | | n | leaf throttle { |
| | | type uint32 { |
| | | range "1..20" { |
| | | description |
| | | "Seconds"; |
| | | } |
| | | } |
| | | description |
| | | "Set throttle update in seconds"; |
| | | } |
| leaf level { | | leaf level { |
| type uint32 { | | type uint32 { |
| range "1..2" { | | range "1..2" { |
| description | | description |
| "Level"; | | "Level"; |
| } | | } |
| } | | } |
| description | | description |
| "Set distribution for one level only"; | | "Set distribution for one level only"; |
| n | } | n | |
| leaf throttle { | | |
| type uint32 { | | |
| range "1..20" { | | |
| description | | |
| "Seconds"; | | |
| } | | |
| } | | |
| description | | |
| "Set throttle update in seconds"; | | |
| } | | |
| container exclude-interarea { | | |
| presence "Indicates a exclude-interarea node is configured."; | | |
| description | | |
| "Don't distribute ISIS inter-area prefixes"; | | |
| } | | |
| container exclude-external { | | |
| presence "Indicates a exclude-external node is configured."; | | |
| description | | |
| "Don't distribute ISIS external prefixes"; | | |
| } | | |
| leaf route-policy { | | |
| type xr:Route-policy-name; | | |
| description | | |
| "Distribute prefixes based on a route policy"; | | |
| } | | } |
| } | | } |
| } | | } |
| container segment-routing { | | container segment-routing { |
| description | | description |
| "IS-IS segment-routing configuration"; | | "IS-IS segment-routing configuration"; |
| container global-block { | | container global-block { |
| presence "Indicates a global-block node is configured."; | | presence "Indicates a global-block node is configured."; |
| description | | description |
| "Prefix-SID Global label Block (SRGB)"; | | "Prefix-SID Global label Block (SRGB)"; |
| leaf lower-bound { | | leaf lower-bound { |
| type uint32 { | | type uint32 { |
| range "16000..1048575" { | | range "16000..1048575" { |
| description | | description |
| "The lower bound of the SRGB"; | | "The lower bound of the SRGB"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Prefix-SID Global label Block (SRGB)"; | | "Prefix-SID Global label Block (SRGB)"; |
| } | | } |
| leaf upper-bound { | | leaf upper-bound { |
| type uint32 { | | type uint32 { |
| range "1..1048575" { | | range "1..1048575" { |
| description | | description |
| "The upper bound SRGB"; | | "The upper bound SRGB"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "The upper bound SRGB"; | | "The upper bound SRGB"; |
| } | | } |
| } | | } |
| } | | } |
| container adjacency { | | container adjacency { |
| description | | description |
| "ISIS adjacency bring up"; | | "ISIS adjacency bring up"; |
| container stagger { | | container stagger { |
| presence "Indicates a stagger node is configured."; | | presence "Indicates a stagger node is configured."; |
| description | | description |
| "Stagger ISIS adjacency bring up"; | | "Stagger ISIS adjacency bring up"; |
| leaf initial-number-of-neighbors { | | leaf initial-number-of-neighbors { |
| type uint32 { | | type uint32 { |
| range "2..65000" { | | range "2..65000" { |
| description | | description |
| "Initial number of neighbors to bring up (default 2)"; | | "Initial number of neighbors to bring up (default 2)"; |
| } | | } |
| } | | } |
| must "../maximum-simultaneous-neighbors"; | | must "../maximum-simultaneous-neighbors"; |
| description | | description |
| "Initial number of neighbors to bring up (default 2)"; | | "Initial number of neighbors to bring up (default 2)"; |
| } | | } |
| leaf maximum-simultaneous-neighbors { | | leaf maximum-simultaneous-neighbors { |
| type uint32 { | | type uint32 { |
| range "2..65000" { | | range "2..65000" { |
| description | | description |
| "Maximum simultaneous neighbors to bring up (default 64)"; | | "Maximum simultaneous neighbors to bring up (default 64)"; |
| } | | } |
| } | | } |
| must "../initial-number-of-neighbors"; | | must "../initial-number-of-neighbors"; |
| description | | description |
| "Maximum simultaneous neighbors to bring up (default 64)"; | | "Maximum simultaneous neighbors to bring up (default 64)"; |
| } | | } |
| } | | } |
| } | | } |
| n | container algorithm { | n | |
| description | | |
| "Standard algorithm definition"; | | |
| container zero { | | |
| presence "Indicates a zero node is configured."; | | |
| description | | |
| "Algorithm number"; | | |
| container address-family { | | |
| description | | |
| "Enter the IS-IS Flex-Algo address-family configuration submode"; | | |
| container ipv4 { | | |
| description | | |
| "IPV4 address family"; | | |
| container unicast { | | |
| presence "Indicates a unicast node is configured."; | | |
| description | | |
| "unicast topology"; | | |
| container maximum-paths { | | |
| description | | |
| "Maximum number of active parallel paths per route"; | | |
| leaf number-of-paths { | | |
| type uint32 { | | |
| range "1..64" { | | |
| description | | |
| "Number of paths"; | | |
| } | | |
| } | | |
| description | | |
| "Number of paths"; | | |
| } | | |
| leaf route-policy { | | |
| type xr:Route-policy-name; | | |
| description | | |
| "Filter routes based on a route policy"; | | |
| } | | |
| } | | |
| } | | |
| } | | |
| container ipv6 { | | |
| description | | |
| "IPV6 address family"; | | |
| container unicast { | | |
| presence "Indicates a unicast node is configured."; | | |
| description | | |
| "unicast topology"; | | |
| container maximum-paths { | | |
| description | | |
| "Maximum number of active parallel paths per route"; | | |
| leaf number-of-paths { | | |
| type uint32 { | | |
| range "1..64" { | | |
| description | | |
| "Number of paths"; | | |
| } | | |
| } | | |
| description | | |
| "Number of paths"; | | |
| } | | |
| leaf route-policy { | | |
| type xr:Route-policy-name; | | |
| description | | |
| "Filter routes based on a route policy"; | | |
| } | | |
| } | | |
| } | | |
| } | | |
| } | | |
| } | | |
| } | | |
| container flex-algos { | | container flex-algos { |
| description | | description |
| "Flex Algorithm definition"; | | "Flex Algorithm definition"; |
| list flex-algo { | | list flex-algo { |
| key "algorithm-number"; | | key "algorithm-number"; |
| description | | description |
| "Flex Algorithm definition"; | | "Flex Algorithm definition"; |
| leaf algorithm-number { | | leaf algorithm-number { |
| type uint32 { | | type uint32 { |
| range "128..255" { | | range "128..255" { |
| description | | description |
| "Algorithm number"; | | "Algorithm number"; |
| } | | } |
| } | | } |
| description | | description |
| "Flex Algorithm definition"; | | "Flex Algorithm definition"; |
| } | | } |
| container affinity { | | container affinity { |
| description | | description |
| "Specify affinity names to exclude"; | | "Specify affinity names to exclude"; |
| container exclude-anies { | | container exclude-anies { |
| description | | description |
| "Exclude objects in flex-algo calculation"; | | "Exclude objects in flex-algo calculation"; |
| leaf-list exclude-any { | | leaf-list exclude-any { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Affinity to exclude"; | | "Affinity to exclude"; |
| } | | } |
| } | | } |
| max-elements "32"; | | max-elements "32"; |
| description | | description |
| "Exclude objects in flex-algo calculation"; | | "Exclude objects in flex-algo calculation"; |
| } | | } |
| } | | } |
| container include-anies { | | container include-anies { |
| description | | description |
| "Include objects in flex-algo calculation"; | | "Include objects in flex-algo calculation"; |
| leaf-list include-any { | | leaf-list include-any { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Affinity to include"; | | "Affinity to include"; |
| } | | } |
| } | | } |
| max-elements "32"; | | max-elements "32"; |
| description | | description |
| "Include objects in flex-algo calculation"; | | "Include objects in flex-algo calculation"; |
| } | | } |
| } | | } |
| container include-alls { | | container include-alls { |
| description | | description |
| "Include objects in flex-algo calculation"; | | "Include objects in flex-algo calculation"; |
| leaf-list include-all { | | leaf-list include-all { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Affinity to include"; | | "Affinity to include"; |
| } | | } |
| } | | } |
| max-elements "32"; | | max-elements "32"; |
| description | | description |
| "Include objects in flex-algo calculation"; | | "Include objects in flex-algo calculation"; |
| } | | } |
| } | | } |
| n | container reverse { | n | |
| description | | |
| "Apply to links in the reverse direction"; | | |
| container exclude-anies { | | |
| description | | |
| "Exclude objects in flex-algo calculation"; | | |
| leaf-list exclude-any { | | |
| type string { | | |
| length "1..32" { | | |
| description | | |
| "Reverse affinity to exclude"; | | |
| } | | |
| } | | |
| max-elements "32"; | | |
| description | | |
| "Exclude objects in flex-algo calculation"; | | |
| } | | |
| } | | |
| container include-anies { | | |
| description | | |
| "Include objects in flex-algo calculation"; | | |
| leaf-list include-any { | | |
| type string { | | |
| length "1..32" { | | |
| description | | |
| "Reverse affinity to include"; | | |
| } | | |
| } | | |
| max-elements "32"; | | |
| description | | |
| "Include objects in flex-algo calculation"; | | |
| } | | |
| } | | |
| container include-alls { | | |
| description | | |
| "Include objects in flex-algo calculation"; | | |
| leaf-list include-all { | | |
| type string { | | |
| length "1..32" { | | |
| description | | |
| "Reverse affinity to include"; | | |
| } | | |
| } | | |
| max-elements "32"; | | |
| description | | |
| "Include objects in flex-algo calculation"; | | |
| } | | |
| } | | |
| } | | |
| } | | |
| leaf minimum-bandwidth { | | |
| type uint32 { | | |
| range "1..4294967295" { | | |
| description | | |
| "Minimum link bandwidth (kbits/sec)"; | | |
| } | | |
| } | | |
| description | | |
| "Specify minimum link bandwidth"; | | |
| } | | |
| leaf maximum-delay { | | |
| type uint32 { | | |
| range "1..10000000" { | | |
| description | | |
| "Maximum link delay (microseconds)"; | | |
| } | | |
| } | | |
| description | | |
| "Specify maximum link delay"; | | |
| } | | } |
| container srlg { | | container srlg { |
| description | | description |
| "Specify SRLG names"; | | "Specify SRLG names"; |
| container exclude-anies { | | container exclude-anies { |
| description | | description |
| "Exclude objects in flex-algo calculation"; | | "Exclude objects in flex-algo calculation"; |
| leaf-list exclude-any { | | leaf-list exclude-any { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "SRLG to exclude"; | | "SRLG to exclude"; |
| } | | } |
| } | | } |
| max-elements "32"; | | max-elements "32"; |
| description | | description |
| "Exclude objects in flex-algo calculation"; | | "Exclude objects in flex-algo calculation"; |
| } | | } |
| } | | } |
| } | | } |
| leaf priority { | | leaf priority { |
| type uint32 { | | type uint32 { |
| range "0..255" { | | range "0..255" { |
| description | | description |
| "Priority value"; | | "Priority value"; |
| } | | } |
| } | | } |
| description | | description |
| "Flex-Algo definition priority"; | | "Flex-Algo definition priority"; |
| } | | } |
| n | leaf metric-type { | n | container metric-type { |
| type uint32 { | | description |
| range "0..255" { | | "Metric-type used by flex-algo calculation"; |
| | | container delay { |
| | | must "not(../te)"; |
| | | presence "Indicates a delay node is configured."; |
| description | | description |
| "Metric-type"; | | "Use delay as metric"; |
| } | | } |
| } | | container te { |
| | | must "not(../delay)"; |
| | | presence "Indicates a te node is configured."; |
| description | | description |
| "Flex-Algo metric-type (0: IGP; 1: Delay; 2: Traffic Engneering Metric, (128-255): Generic-metric types"; | | "Use Traffic Engineering metric"; |
| | | } |
| } | | } |
| container fast-reroute { | | container fast-reroute { |
| description | | description |
| "Configure Fast ReRoute"; | | "Configure Fast ReRoute"; |
| container disable { | | container disable { |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable Fast ReRoute for Flex-Algo"; | | "Disable Fast ReRoute for Flex-Algo"; |
| } | | } |
| } | | } |
| container microloop { | | container microloop { |
| description | | description |
| "Configure Microloop"; | | "Configure Microloop"; |
| container avoidance { | | container avoidance { |
| description | | description |
| "Configure Microloop Avoidance"; | | "Configure Microloop Avoidance"; |
| container disable { | | container disable { |
| presence "Indicates a disable node is configured."; | | presence "Indicates a disable node is configured."; |
| description | | description |
| "Disable Microloop Avoidance for Flex-Algo"; | | "Disable Microloop Avoidance for Flex-Algo"; |
| } | | } |
| } | | } |
| } | | } |
| n | container ucmp { | n | |
| description | | |
| "Configure UCMP"; | | |
| container disable { | | |
| presence "Indicates a disable node is configured."; | | |
| description | | |
| "Disable UCMP for Flex-Algo"; | | |
| } | | |
| } | | |
| container advertise-definition { | | container advertise-definition { |
| presence "Indicates a advertise-definition node is configured."; | | presence "Indicates a advertise-definition node is configured."; |
| description | | description |
| "Advertise the Flex-Algo Definition"; | | "Advertise the Flex-Algo Definition"; |
| } | | } |
| container prefix-metric { | | container prefix-metric { |
| presence "Indicates a prefix-metric node is configured."; | | presence "Indicates a prefix-metric node is configured."; |
| description | | description |
| "Use Flex-Algo Prefix Metric"; | | "Use Flex-Algo Prefix Metric"; |
| t | } | t | |
| container data-plane { | | |
| description | | |
| "Flex-Algo Data Plane"; | | |
| container segment-routing { | | |
| presence "Indicates a segment-routing node is configured."; | | |
| description | | |
| "Segment Routing"; | | |
| } | | |
| container ip { | | |
| presence "Indicates a ip node is configured."; | | |
| description | | |
| "IP"; | | |
| } | | |
| } | | |
| container address-family { | | |
| description | | |
| "Enter the IS-IS Flex-Algo address-family configuration submode"; | | |
| container ipv4 { | | |
| description | | |
| "IPV4 address family"; | | |
| container unicast { | | |
| presence "Indicates a unicast node is configured."; | | |
| description | | |
| "unicast topology"; | | |
| container maximum-paths { | | |
| description | | |
| "Maximum number of active parallel paths per route"; | | |
| leaf number-of-paths { | | |
| type uint32 { | | |
| range "1..64" { | | |
| description | | |
| "Number of paths"; | | |
| } | | |
| } | | |
| description | | |
| "Number of paths"; | | |
| } | | |
| leaf route-policy { | | |
| type xr:Route-policy-name; | | |
| description | | |
| "Filter routes based on a route policy"; | | |
| } | | |
| } | | |
| } | | |
| } | | |
| container ipv6 { | | |
| description | | |
| "IPV6 address family"; | | |
| container unicast { | | |
| presence "Indicates a unicast node is configured."; | | |
| description | | |
| "unicast topology"; | | |
| container maximum-paths { | | |
| description | | |
| "Maximum number of active parallel paths per route"; | | |
| leaf number-of-paths { | | |
| type uint32 { | | |
| range "1..64" { | | |
| description | | |
| "Number of paths"; | | |
| } | | |
| } | | |
| description | | |
| "Number of paths"; | | |
| } | | |
| leaf route-policy { | | |
| type xr:Route-policy-name; | | |
| description | | |
| "Filter routes based on a route policy"; | | |
| } | | |
| } | | |
| } | | |
| } | | |
| } | | } |
| } | | } |
| } | | } |
| container affinity-maps { | | container affinity-maps { |
| description | | description |
| "Affinity map configuration"; | | "Affinity map configuration"; |
| list affinity-map { | | list affinity-map { |
| key "affinity-map-name"; | | key "affinity-map-name"; |
| description | | description |
| "Affinity map configuration"; | | "Affinity map configuration"; |
| leaf affinity-map-name { | | leaf affinity-map-name { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Affinity attribute name"; | | "Affinity attribute name"; |
| } | | } |
| } | | } |
| description | | description |
| "Affinity map configuration"; | | "Affinity map configuration"; |
| } | | } |
| leaf bit-position { | | leaf bit-position { |
| type uint32 { | | type uint32 { |
| range "0..255" { | | range "0..255" { |
| description | | description |
| "Bit position"; | | "Bit position"; |
| } | | } |
| } | | } |
| mandatory true; | | mandatory true; |
| description | | description |
| "Bit position for affinity attribute value"; | | "Bit position for affinity attribute value"; |
| } | | } |
| } | | } |
| } | | } |
| container srlg { | | container srlg { |
| presence "Indicates a srlg node is configured."; | | presence "Indicates a srlg node is configured."; |
| description | | description |
| "ISIS SRLG submode"; | | "ISIS SRLG submode"; |
| container names { | | container names { |
| description | | description |
| "SRLG Name"; | | "SRLG Name"; |
| list name { | | list name { |
| key "srlg-name"; | | key "srlg-name"; |
| description | | description |
| "SRLG Name"; | | "SRLG Name"; |
| leaf srlg-name { | | leaf srlg-name { |
| type xr:Cisco-ios-xr-string { | | type xr:Cisco-ios-xr-string { |
| length "1..64" { | | length "1..64" { |
| description | | description |
| "SRLG Name"; | | "SRLG Name"; |
| } | | } |
| } | | } |
| description | | description |
| "SRLG Name"; | | "SRLG Name"; |
| } | | } |
| leaf admin-weight { | | leaf admin-weight { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Value added to link admin-weight during SRLG-aware path computation"; | | "Value added to link admin-weight during SRLG-aware path computation"; |
| } | | } |
| } | | } |
| description | | description |
| "Administrative weight: default inherited from the global admin-weight"; | | "Administrative weight: default inherited from the global admin-weight"; |
| } | | } |
| container static { | | container static { |
| description | | description |
| "Configure static SRLG under name"; | | "Configure static SRLG under name"; |
| container ipv4 { | | container ipv4 { |
| description | | description |
| "IPv4 address"; | | "IPv4 address"; |
| list address { | | list address { |
| must "next-hop"; | | must "next-hop"; |
| key "local-address"; | | key "local-address"; |
| description | | description |
| "IPv4 address of local end-point of the link"; | | "IPv4 address of local end-point of the link"; |
| leaf local-address { | | leaf local-address { |
| type inet:ipv4-address-no-zone; | | type inet:ipv4-address-no-zone; |
| description | | description |
| "IPv4 address of local end-point of the link"; | | "IPv4 address of local end-point of the link"; |
| } | | } |
| container next-hop { | | container next-hop { |
| description | | description |
| "Next hop of the link"; | | "Next hop of the link"; |
| list address { | | list address { |
| key "remote-address"; | | key "remote-address"; |
| description | | description |
| "IPv4 address of local end-point of the link"; | | "IPv4 address of local end-point of the link"; |
| leaf remote-address { | | leaf remote-address { |
| type inet:ipv4-address-no-zone; | | type inet:ipv4-address-no-zone; |
| description | | description |
| "IPv4 address of remote end-point of the link"; | | "IPv4 address of remote end-point of the link"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| leaf admin-weight { | | leaf admin-weight { |
| type uint32 { | | type uint32 { |
| range "0..16777215" { | | range "0..16777215" { |
| description | | description |
| "Value added to link admin-weight during SRLG-aware path computation"; | | "Value added to link admin-weight during SRLG-aware path computation"; |
| } | | } |
| } | | } |
| description | | description |
| "Default administrative weight for all SRLGs, default is 1"; | | "Default administrative weight for all SRLGs, default is 1"; |
| } | | } |
| } | | } |
| container purge-transmit { | | container purge-transmit { |
| description | | description |
| "Control TLVs permitted in purge LSP"; | | "Control TLVs permitted in purge LSP"; |
| container strict { | | container strict { |
| presence "Indicates a strict node is configured."; | | presence "Indicates a strict node is configured."; |
| description | | description |
| "Only authentication TLV is allowed"; | | "Only authentication TLV is allowed"; |
| leaf apply-for-level-only { | | leaf apply-for-level-only { |
| type enumeration { | | type enumeration { |
| enum "level-1" { | | enum "level-1" { |
| value 1; | | value 1; |
| description | | description |
| "Apply for Level-1 only"; | | "Apply for Level-1 only"; |
| } | | } |
| enum "level-2" { | | enum "level-2" { |
| value 2; | | value 2; |
| description | | description |
| "Apply for Level-2 only"; | | "Apply for Level-2 only"; |
| } | | } |
| } | | } |
| description | | description |
| "configure this node"; | | "configure this node"; |
| } | | } |
| } | | } |
| } | | } |
| container receive { | | container receive { |
| description | | description |
| "Control if ASLA takes precedence over Legacy"; | | "Control if ASLA takes precedence over Legacy"; |
| container application { | | container application { |
| description | | description |
| "Select Application"; | | "Select Application"; |
| container flex-algo { | | container flex-algo { |
| description | | description |
| "Flex-Algo Applciation"; | | "Flex-Algo Applciation"; |
| container delay { | | container delay { |
| description | | description |
| "Unidirectionial Min Delay metric"; | | "Unidirectionial Min Delay metric"; |
| container app-only { | | container app-only { |
| presence "Indicates a app-only node is configured."; | | presence "Indicates a app-only node is configured."; |
| description | | description |
| "ASLA to take precedence"; | | "ASLA to take precedence"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container attestation { | | container attestation { |
| presence "Indicates a attestation node is configured."; | | presence "Indicates a attestation node is configured."; |
| description | | description |
| "ISIS Attestation submode"; | | "ISIS Attestation submode"; |
| container application { | | container application { |
| description | | description |
| "Application"; | | "Application"; |
| container flex-algo { | | container flex-algo { |
| presence "Indicates a flex-algo node is configured."; | | presence "Indicates a flex-algo node is configured."; |
| description | | description |
| "Flexible Algorithm application"; | | "Flexible Algorithm application"; |
| container trust-vector { | | container trust-vector { |
| presence "Indicates a trust-vector node is configured."; | | presence "Indicates a trust-vector node is configured."; |
| description | | description |
| "Trust Vector Configuration"; | | "Trust Vector Configuration"; |
| container boot-integrity-passed { | | container boot-integrity-passed { |
| description | | description |
| "Boot Integrity Passed"; | | "Boot Integrity Passed"; |
| leaf affinity { | | leaf affinity { |
| type string { | | type string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Affinity name"; | | "Affinity name"; |
| } | | } |
| } | | } |
| description | | description |
| "Affinity configuration"; | | "Affinity configuration"; |
| } | | } |
| } | | } |
| container boot-integrity-failed { | | container boot-integrity-failed { |
| description | | description |
| "Boot Integrity Failed"; | | "Boot Integrity Failed"; |
| leaf affinity { | | leaf affinity { |
| type string { | | type string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Affinity name"; | | "Affinity name"; |
| } | | } |
| } | | } |
| description | | description |
| "Affinity configuration"; | | "Affinity configuration"; |
| } | | } |
| } | | } |
| container failures-found { | | container failures-found { |
| description | | description |
| "Failures Found"; | | "Failures Found"; |
| leaf affinity { | | leaf affinity { |
| type string { | | type string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Affinity name"; | | "Affinity name"; |
| } | | } |
| } | | } |
| description | | description |
| "Affinity configuration"; | | "Affinity configuration"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| container traffic-engineering { | | container traffic-engineering { |
| presence "Indicates a traffic-engineering node is configured."; | | presence "Indicates a traffic-engineering node is configured."; |
| description | | description |
| "Traffic-engineering application"; | | "Traffic-engineering application"; |
| container trust-vector { | | container trust-vector { |
| presence "Indicates a trust-vector node is configured."; | | presence "Indicates a trust-vector node is configured."; |
| description | | description |
| "Trust Vector Configuration"; | | "Trust Vector Configuration"; |
| container boot-integrity-passed { | | container boot-integrity-passed { |
| description | | description |
| "Boot Integrity Passed"; | | "Boot Integrity Passed"; |
| leaf affinity { | | leaf affinity { |
| type string { | | type string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Affinity name"; | | "Affinity name"; |
| } | | } |
| } | | } |
| description | | description |
| "Affinity configuration"; | | "Affinity configuration"; |
| } | | } |
| } | | } |
| container boot-integrity-failed { | | container boot-integrity-failed { |
| description | | description |
| "Boot Integrity Failed"; | | "Boot Integrity Failed"; |
| leaf affinity { | | leaf affinity { |
| type string { | | type string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Affinity name"; | | "Affinity name"; |
| } | | } |
| } | | } |
| description | | description |
| "Affinity configuration"; | | "Affinity configuration"; |
| } | | } |
| } | | } |
| container failures-found { | | container failures-found { |
| description | | description |
| "Failures Found"; | | "Failures Found"; |
| leaf affinity { | | leaf affinity { |
| type string { | | type string { |
| length "1..32" { | | length "1..32" { |
| description | | description |
| "Affinity name"; | | "Affinity name"; |
| } | | } |
| } | | } |
| description | | description |
| "Affinity configuration"; | | "Affinity configuration"; |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |
| } | | } |